import { ViennaClient } from '@vienna/sdk';

const vienna = new ViennaClient({
  apiKey: 'vna_your_api_key',
  baseUrl: 'https://console.regulator.ai', // optional
  timeout: 30000, // optional, default 30s
  retries: 3, // optional, default 3
  onError: (error) => console.error('Vienna error:', error), // optional
});

const config: ViennaConfig = {
  apiKey: process.env.VIENNA_API_KEY!,
  baseUrl: 'https://console.regulator.ai',
  timeout: 60000, // 1 minute
  retries: 5,
  onError: (error) => {
    console.error('[Vienna SDK Error]', error.message);
    // Send to error tracking service
    errorTracker.captureException(error);
  },
};

// Submit a wire transfer intent
const result = await vienna.intent.submit({
  action: 'wire_transfer',
  source: 'billing-bot',
  tenantId: 'acme-corp',
  payload: {
    amount: 75000,
    currency: 'USD',
    recipient: 'vendor-123',
    reason: 'Monthly vendor payment',
  },
  metadata: {
    requestId: 'req-abc123',
    context: 'scheduled_payment',
  },
});

// Handle the result based on status
switch (result.status) {
  case 'executed':
    console.log('Payment processed:', result.executionId);
    break;
  case 'pending_approval':
    console.log('Awaiting approval:', result.approvalId);
    // Set up webhook or polling to wait for approval
    break;
  case 'denied':
    console.log('Payment denied:', result.reason);
    break;
}

// Check intent status
const status = await vienna.intent.status('int-abc123');

console.log('Status:', status.status);
console.log('Risk tier:', status.riskTier);
console.log('Policy matches:', status.policyMatches);

if (status.status === 'executed') {
  console.log('Execution ID:', status.executionId);
  console.log('Warrant ID:', status.warrantId);
}

// Simulate a high-value transfer to test policies
const simulation = await vienna.intent.simulate({
  action: 'wire_transfer',
  source: 'billing-bot',
  payload: {
    amount: 500000, // Half a million
    currency: 'USD',
    recipient: 'external-vendor',
  },
});

console.log('Would execute?', simulation.wouldExecute);
console.log('Final status:', simulation.status);
console.log('Risk tier:', simulation.riskTier);
console.log('Required approvals:', simulation.requiredApprovals);
console.log('Policy matches:', simulation.policyMatches);

// List all pending intents
const pendingIntents = await vienna.intent.list({ 
  status: 'pending_approval',
  limit: 20 
});

// List intents from specific agent
const agentIntents = await vienna.intent.list({ 
  source: 'billing-bot' 
});

// Create a policy for high-value transaction approval
const policy = await vienna.policies.create({
  name: 'High-Value Transaction Gate',
  description: 'Require T2 approval for transfers over $50,000',
  priority: 100,
  enabled: true,
  conditions: [
    {
      field: 'action',
      operator: 'equals',
      value: 'wire_transfer',
    },
    {
      field: 'payload.amount',
      operator: 'gt',
      value: 50000,
    },
  ],
  actionOnMatch: 'require_approval',
  approvalTier: 'T2',
  tags: ['financial', 'high-risk'],
});

console.log('Created policy:', policy.id);

// Update policy priority and enable it
const updated = await vienna.policies.update('pol-123', {
  priority: 150,
  enabled: true,
  description: 'Updated: Require approval for high-value transfers',
});

// Disable a policy temporarily
await vienna.policies.update('pol-456', {
  enabled: false,
});

// Delete a policy
await vienna.policies.delete('pol-123');

console.log('Policy deleted');

// List all active policies
const activePolicies = await vienna.policies.list({
  enabled: true,
});

// List policies for specific tenant
const tenantPolicies = await vienna.policies.list({
  tenantId: 'acme-corp',
});

// List policies by tag
const financialPolicies = await vienna.policies.list({
  tag: 'financial',
});

// Test a policy evaluation
const evaluation = await vienna.policies.evaluate({
  action: 'wire_transfer',
  payload: {
    amount: 100000,
    currency: 'USD',
    recipient: 'external-vendor',
  },
  source: 'billing-bot',
  tenantId: 'acme-corp',
});

console.log('Matched policies:', evaluation.matchedPolicies);
console.log('Final action:', evaluation.finalAction);
console.log('Risk tier:', evaluation.riskTier);
console.log('Details:', evaluation.details);

// Get available policy templates
const templates = await vienna.policies.templates();

templates.forEach(template => {
  console.log(`Template: ${template.name}`);
  console.log(`Industry: ${template.industry}`);
  console.log(`Description: ${template.description}`);
});

// Example templates:
// - Financial Services (SOX compliance)
// - Healthcare (HIPAA compliance)
// - DevOps (deployment gates)
// - Legal (filing controls)

// Register a new agent
const agent = await vienna.fleet.register({
  name: 'customer-support-bot',
  type: 'autonomous',
  capabilities: ['send_email', 'query_database', 'create_ticket'],
  metadata: {
    framework: 'langchain',
    version: '1.0.0',
    owner: 'support-team',
  },
});

console.log('Agent registered:', agent.id);
console.log('Initial trust score:', agent.trustScore);

// Get agent details
const agent = await vienna.fleet.get('agt-abc123');

console.log('Agent name:', agent.name);
console.log('Status:', agent.status);
console.log('Trust score:', agent.trustScore);
console.log('Risk tier:', agent.riskTier);
console.log('Total intents:', agent.totalIntents);
console.log('Denied intents:', agent.deniedIntents);
console.log('Last activity:', agent.lastActivityAt);

// Update agent capabilities
const updated = await vienna.fleet.update('agt-abc123', {
  description: 'Enhanced support bot with new capabilities',
  capabilities: ['send_email', 'query_database', 'create_ticket', 'escalate_to_human'],
  tags: ['support', 'production', 'enhanced'],
});

// Suspend an agent
await vienna.fleet.update('agt-abc123', {
  status: 'suspended',
});

// Get agent metrics
const metrics = await vienna.fleet.metrics('agt-abc123');

console.log('Total intents:', metrics.totalIntents);
console.log('Approved intents:', metrics.approvedIntents);
console.log('Denied intents:', metrics.deniedIntents);
console.log('Pending intents:', metrics.pendingIntents);
console.log('Average response time:', metrics.avgResponseTimeMs, 'ms');
console.log('Current trust score:', metrics.trustScore);
console.log('Risk tier:', metrics.riskTier);
console.log('Period:', metrics.periodStart, 'to', metrics.periodEnd);

// Get recent agent activity
const activity = await vienna.fleet.activity('agt-abc123', {
  limit: 50,
  offset: 0,
});

console.log('Total activities:', activity.total);
activity.items.forEach(item => {
  console.log(`${item.timestamp}: ${item.action} - ${item.status}`);
  if (item.details) {
    console.log('Details:', item.details);
  }
});

// Get next page
const nextPage = await vienna.fleet.activity('agt-abc123', {
  limit: 50,
  offset: 50,
});

// Get unresolved alerts
const unresolvedAlerts = await vienna.fleet.alerts({
  resolved: false,
});

// Get critical alerts for specific agent
const criticalAlerts = await vienna.fleet.alerts({
  severity: 'critical',
  agentId: 'agt-abc123',
});

unresolvedAlerts.forEach(alert => {
  console.log(`Alert ${alert.id}: ${alert.severity}`);
  console.log('Message:', alert.message);
  console.log('Agent:', alert.agentId);
  console.log('Created:', alert.createdAt);
});

// Get pending approvals
const pending = await vienna.approvals.list({
  status: 'pending',
});

// Get approvals from specific agent
const agentApprovals = await vienna.approvals.list({
  source: 'billing-bot',
});

// Get high-risk approvals
const highRisk = await vienna.approvals.list({
  riskTier: 'T2',
});

pending.forEach(approval => {
  console.log(`Approval ${approval.id}:`);
  console.log('Intent:', approval.intentId);
  console.log('Action:', approval.action);
  console.log('Source:', approval.source);
  console.log('Risk tier:', approval.riskTier);
  console.log('Expires at:', approval.expiresAt);
});

// Approve a pending intent
const approved = await vienna.approvals.approve('apr-abc123', {
  operator: 'jane.doe',
  notes: 'Approved after verifying vendor details and payment amount',
});

console.log('Approval status:', approved.status);
console.log('Approved by:', approved.operator);
console.log('Notes:', approved.notes);
console.log('Approved at:', approved.updatedAt);

// Check if intent is now executing
const intentStatus = await vienna.intent.status(approved.intentId);
console.log('Intent status:', intentStatus.status);

// Deny a pending intent
const denied = await vienna.approvals.deny('apr-abc123', {
  operator: 'john.smith',
  reason: 'Payment amount exceeds approved vendor contract limit',
});

console.log('Denial status:', denied.status);
console.log('Denied by:', denied.operator);
console.log('Reason:', denied.reason);
console.log('Denied at:', denied.updatedAt);

// Create a Slack integration
const slackIntegration = await vienna.integrations.create({
  type: 'slack',
  name: 'Engineering Alerts',
  config: {
    webhook_url: 'https://hooks.slack.com/services/YOUR_SLACK_WEBHOOK_URL',
    channel: '#ai-governance',
  },
  eventTypes: [
    'approval_required',
    'execution_failed',
    'policy_violation',
    'agent_suspended',
  ],
});

// Create a webhook integration
const webhookIntegration = await vienna.integrations.create({
  type: 'webhook',
  name: 'Monitoring Dashboard',
  config: {
    url: 'https://monitoring.acme.com/vienna-webhooks',
    secret: 'whsec_your_webhook_secret',
    headers: {
      'Authorization': 'Bearer your_api_key',
    },
  },
  eventTypes: ['execution_complete', 'verification_mismatch'],
});

// List all integrations
const integrations = await vienna.integrations.list();

integrations.forEach(integration => {
  console.log(`Integration ${integration.id}: ${integration.name}`);
  console.log('Type:', integration.type);
  console.log('Enabled:', integration.enabled);
  console.log('Event types:', integration.eventTypes);
  console.log('Last tested:', integration.lastTestedAt);
});

// Test an integration
const testResult = await vienna.integrations.test('int-abc123');

if (testResult.success) {
  console.log('Integration test successful!');
  console.log('Latency:', testResult.latencyMs, 'ms');
} else {
  console.log('Integration test failed:', testResult.error);
}

// Test result includes:
// - success: boolean
// - latencyMs: number
// - error?: string

// Delete an integration
await vienna.integrations.delete('int-abc123');

console.log('Integration deleted');

// Generate a quarterly compliance report
const report = await vienna.compliance.generate({
  type: 'quarterly',
  periodStart: '2026-01-01',
  periodEnd: '2026-03-31',
  tenantId: 'acme-corp', // optional
});

console.log('Report ID:', report.id);
console.log('Status:', report.status);
console.log('Type:', report.type);
console.log('Period:', report.periodStart, 'to', report.periodEnd);

if (report.status === 'ready') {
  console.log('Download URL:', report.downloadUrl);
  console.log('Summary:', report.summary);
} else {
  console.log('Report is still generating...');
}

// Get a compliance report
const report = await vienna.compliance.get('rpt-abc123');

if (report.status === 'ready') {
  console.log('Report ready!');
  console.log('Total intents:', report.summary.totalIntents);
  console.log('Approved intents:', report.summary.approvedIntents);
  console.log('Denied intents:', report.summary.deniedIntents);
  console.log('Policy violations:', report.summary.policyViolations);
  console.log('Compliance score:', report.summary.complianceScore);
  
  // Download the report
  const response = await fetch(report.downloadUrl);
  const pdfBuffer = await response.arrayBuffer();
}

// Get stats for the last 30 days
const stats = await vienna.compliance.quickStats({
  days: 30,
  tenantId: 'acme-corp', // optional
});

console.log('Last 30 days stats:');
console.log('Total intents:', stats.totalIntents);
console.log('Approved intents:', stats.approvedIntents);
console.log('Denied intents:', stats.deniedIntents);
console.log('Pending approvals:', stats.pendingApprovals);
console.log('Policy violations:', stats.policyViolations);
console.log('Average response time:', stats.avgResponseTimeMs, 'ms');
console.log('Compliance score:', stats.complianceScore, '%');

// Top violating agents
console.log('Top violating agents:');
stats.topViolatingAgents.forEach(agent => {
  console.log(`- ${agent.agentId}: ${agent.violations} violations`);
});