import {
  WorkflowBuilder,
  WorkflowExecutionEngine,
  TriggerEngine,
} from '@/lib/plugins/workflows'

// 1. Build a workflow definition
const workflow = new WorkflowBuilder('Welcome New Members', 'system')
  .description('Greet new members when they join a channel')
  .onEvent('member.joined', { channelIds: ['channel-general'] })
  .addStep('greet', 'Send welcome message', {
    type: 'send_message',
    channelId: '{{trigger.channelId}}',
    content: 'Welcome to the team, {{trigger.userId}}!',
  })
  .scopes(['write:messages'])
  .build()

// 2. Register the workflow with the trigger engine
const triggerEngine = new TriggerEngine()
triggerEngine.registerWorkflow(workflow)

// 3. When an event occurs, evaluate triggers
const matches = triggerEngine.evaluateEvent('member.joined', {
  channelId: 'channel-general',
  userId: 'user-456',
})

// 4. Execute matched workflows
const executionEngine = new WorkflowExecutionEngine({
  sleepFn: async () => {},  // No-op for fast execution
})

for (const match of matches) {
  const run = await executionEngine.startRun(match.workflow, match.triggerInfo)
  console.log('Run status:', run.status)  // 'completed'
}

const workflow = new WorkflowBuilder('Log Messages', 'admin')
  .onEvent('message.created', {
    channelIds: ['channel-support'],
    conditions: [
      {
        field: 'content',
        operator: 'contains',
        value: 'urgent',
      },
    ],
  })
  .addStep('notify', 'Alert on-call', {
    type: 'send_message',
    channelId: 'channel-oncall',
    content: 'Urgent message in #support: {{trigger.content}}',
  })
  .build()

const workflow = new WorkflowBuilder('Daily Standup Reminder', 'admin')
  .onSchedule('0 9 * * 1-5', { timezone: 'America/New_York' })
  .addStep('remind', 'Post standup reminder', {
    type: 'send_message',
    channelId: 'channel-team',
    content: 'Time for standup! Please post your update.',
  })
  .build()

import { WorkflowScheduler, ScheduleStore } from '@/lib/plugins/workflows'

const scheduler = new WorkflowScheduler(new ScheduleStore())
const schedule = scheduler.createSchedule(workflow)

// The scheduler fires callbacks when a schedule is due
scheduler.onScheduleFired = (schedule) => {
  console.log('Schedule fired for workflow:', schedule.workflowId)
}

// Process due schedules manually
const fired = scheduler.tick(new Date())

// Or start an automatic tick loop (checks every 60s by default)
scheduler.start()
// ... later
scheduler.stop()

const workflow = new WorkflowBuilder('GitHub Push Handler', 'admin')
  .onWebhook(['POST'], {
    secret: 'whsec_my_github_secret',
    contentType: 'application/json',
  })
  .addStep('notify', 'Post push notification', {
    type: 'send_message',
    channelId: 'channel-dev',
    content: 'Push to {{trigger.body.ref}} by {{trigger.body.pusher.name}}',
  })
  .build()

const match = triggerEngine.evaluateWebhook(
  workflow.id,
  'POST',
  { ref: 'refs/heads/main', pusher: { name: 'alice' } },
  { 'content-type': 'application/json' }
)

const workflow = new WorkflowBuilder('Deploy to Production', 'admin')
  .onManual({
    allowedRoles: ['admin', 'owner'],
    allowedUserIds: ['user-lead'],
  })
  .addInput({
    name: 'environment',
    type: 'string',
    required: true,
    description: 'Target environment',
  })
  .addStep('deploy', 'Trigger deploy', {
    type: 'http_request',
    url: 'https://deploy.example.com/api/deploy',
    method: 'POST',
    body: { env: '{{inputs.environment}}' },
  })
  .build()

const match = triggerEngine.evaluateManual(
  workflow.id,
  'user-lead',
  ['admin'],
  { environment: 'production' }
)

interface StepSettings {
  retryAttempts: number       // Default: 3
  retryBackoff: 'fixed' | 'linear' | 'exponential'  // Default: 'exponential'
  retryDelayMs: number        // Default: 1000
  maxRetryDelayMs: number     // Default: 60000
  timeoutMs: number           // Default: 30000
  skipOnFailure: boolean      // Default: false
  idempotent: boolean         // Default: true
  idempotencyKey?: string     // Template expression for dedup
}

const workflow = new WorkflowBuilder('Pipeline', 'admin')
  .onManual()
  .addStep('fetch', 'Fetch data', {
    type: 'http_request',
    url: 'https://api.example.com/data',
    method: 'GET',
  }, { outputKey: 'apiData' })
  .addStep('transform', 'Process data', {
    type: 'transform_data',
    input: 'apiData.body',
    transform: 'map',
  }, { dependsOn: ['fetch'] })
  .addStep('notify', 'Send results', {
    type: 'send_message',
    channelId: 'channel-results',
    content: 'Data processed successfully',
  }, { dependsOn: ['transform'] })
  .build()

.addStep('escalate', 'Escalate to manager', {
  type: 'send_message',
  channelId: 'channel-managers',
  content: 'Issue requires escalation',
}, {
  conditions: [
    { field: 'priority', operator: 'equals', value: 'critical' },
  ],
})

{
  type: 'send_message',
  channelId: '{{trigger.channelId}}',
  content: 'Hello {{trigger.userId}}!',
  threadId: '{{trigger.threadId}}',  // Optional: reply in thread
}

{
  type: 'http_request',
  url: 'https://api.example.com/webhook',
  method: 'POST',
  headers: { 'Authorization': 'Bearer {{inputs.apiKey}}' },
  body: { event: '{{trigger.eventType}}' },
  responseFormat: 'json',
}

{
  type: 'transform_data',
  input: 'apiData.body.items',
  transform: 'map',
}

{
  type: 'conditional_branch',
  branches: [
    {
      name: 'High Priority',
      conditions: [{ field: 'priority', operator: 'equals', value: 'high' }],
      targetSteps: ['escalate'],
    },
    {
      name: 'Normal',
      conditions: [{ field: 'priority', operator: 'equals', value: 'normal' }],
      targetSteps: ['log'],
    },
  ],
  defaultSteps: ['archive'],
}

{
  type: 'approval',
  approverIds: ['user-manager', 'user-lead'],
  message: 'Approve deployment to production?',
  timeoutMs: 3600000,   // 1 hour
  minApprovals: 1,
  notificationChannelId: 'channel-approvals',
  escalationUserIds: ['user-vp'],
}

{
  type: 'delay',
  durationMs: 60000,  // 1 minute
}

{
  type: 'set_variable',
  variableName: 'greeting',
  value: 'Hello, {{trigger.userId}}!',
}

{
  type: 'parallel',
  branches: [['notify-slack', 'notify-email'], ['log-analytics']],
  waitForAll: true,  // Wait for all branches (false = first to complete)
}

{
  type: 'loop',
  collection: 'apiData.body.users',
  itemVariable: 'currentUser',
  indexVariable: 'index',
  bodySteps: ['greet-user'],
  maxIterations: 100,
}

{
  type: 'channel_action',
  subAction: 'create',         // 'create' | 'archive' | 'add_member' | 'remove_member' | 'update_topic'
  channelName: 'incident-123',
}

{
  type: 'user_action',
  subAction: 'send_dm',  // 'assign_role' | 'send_dm' | 'notify'
  userId: '{{trigger.userId}}',
  message: 'Your request has been processed.',
}

{
  type: 'send_message',
  channelId: '{{trigger.channelId}}',
  content: 'User {{trigger.userId}} created ticket #{{apiResponse.ticketId}}',
}

import { ApprovalGateManager, ApprovalStore } from '@/lib/plugins/workflows'

const gate = new ApprovalGateManager(new ApprovalStore())

const request = gate.createRequest(
  'run-001',
  'step-approve',
  'workflow-001',
  {
    type: 'approval',
    approverIds: ['user-manager', 'user-lead'],
    message: 'Approve release v2.0?',
    timeoutMs: 3600000,
    minApprovals: 2,
    escalationUserIds: ['user-vp'],
  }
)

// Approve
const updated = gate.approve(request.id, 'user-manager', 'Looks good!')

// Reject
const rejected = gate.reject(request.id, 'user-lead', 'Needs more testing')

// Process expired requests (run periodically)
const expired = gate.processExpired()
// If escalation users are configured, the request is escalated first
// before being marked as expired.

gate.onApprovalResolved = (request) => {
  console.log(`Approval ${request.id}: ${request.status}`)
  // Resume or fail the workflow run
}

gate.onApprovalEscalated = (request) => {
  console.log(`Escalated to:`, request.escalationUserIds)
}

gate.onNotify = (userIds, message, data) => {
  // Send notifications to approvers
}

import { WorkflowExecutionEngine } from '@/lib/plugins/workflows'

const engine = new WorkflowExecutionEngine({
  enableAudit: true,
  maxRunHistory: 1000,
})

const run = await engine.startRun(workflow, triggerInfo, {
  apiKey: 'sk-xxx',  // Input variables
})

console.log('Status:', run.status)
console.log('Steps:', run.stepResults.length)

// Cancel a running workflow
engine.cancelRun(run.id)

// Retry a failed workflow
const retryRun = await engine.retryRun(run.id, workflow)

// Get a specific run
const run = engine.getRun('run-001')

// List runs by status
const failedRuns = engine.listRuns({ status: 'failed' })

// Active run count
const active = engine.getActiveRunCount(workflow.id)

const log = engine.getAuditLog({
  workflowId: workflow.id,
  eventType: 'workflow.step_failed',
})

for (const entry of log) {
  console.log(entry.timestamp, entry.eventType, entry.description)
}

import {
  parseCronExpression,
  parseCronField,
  matchesCron,
  getNextCronTime,
} from '@/lib/plugins/workflows'

// Parse a cron expression into component fields
const fields = parseCronExpression('0 9 * * 1-5')
// { minute: [0], hour: [9], dayOfMonth: [1..31], month: [1..12], dayOfWeek: [1,2,3,4,5] }

// Check if a cron matches a specific time
const matches = matchesCron('0 9 * * 1-5', new Date(), 'UTC')

// Calculate the next execution time
const nextRun = getNextCronTime('0 9 * * 1-5', new Date(), 'UTC')

interface WorkflowSettings {
  maxExecutionTimeMs: number       // Default: 300000 (5 min)
  maxRetryAttempts: number         // Default: 3
  continueOnFailure: boolean       // Default: false
  timezone: string                 // Default: 'UTC'
  auditInputsOutputs: boolean     // Default: true
  maxConcurrentExecutions: number  // Default: 1
  requiresApproval: boolean        // Default: false
}

const workflow = new WorkflowBuilder('Heavy Pipeline', 'admin')
  .onManual()
  .settings({
    maxExecutionTimeMs: 600000,      // 10 minutes
    maxRetryAttempts: 5,
    continueOnFailure: true,
    maxConcurrentExecutions: 3,
  })
  .addStep(/* ... */)
  .build()

import { validateWorkflowDefinition } from '@/lib/plugins/workflows'

const result = validateWorkflowDefinition(definition)
if (!result.valid) {
  for (const error of result.errors) {
    console.log(`[${error.severity}] ${error.field}: ${error.message}`)
  }
}

type WorkflowAuditEventType =
  | 'workflow.created' | 'workflow.updated' | 'workflow.deleted'
  | 'workflow.enabled' | 'workflow.disabled'
  | 'workflow.run_started' | 'workflow.run_completed'
  | 'workflow.run_failed' | 'workflow.run_cancelled' | 'workflow.run_retried'
  | 'workflow.step_started' | 'workflow.step_completed'
  | 'workflow.step_failed' | 'workflow.step_skipped' | 'workflow.step_retried'
  | 'workflow.approval_requested' | 'workflow.approval_granted'
  | 'workflow.approval_rejected' | 'workflow.approval_expired'
  | 'workflow.approval_escalated'
  | 'workflow.schedule_created' | 'workflow.schedule_updated'
  | 'workflow.schedule_deleted' | 'workflow.schedule_fired'