const contentTypes = {
  battleCards: {
    structure: [
      'competitor_overview',
      'strengths',
      'weaknesses', 
      'our_differentiators',
      'landmines_to_plant',
      'objection_handlers',
      'customer_wins'
    ],
    updateTrigger: ['competitor_news', 'product_update', 'win_loss_feedback'],
    format: 'notion_page'
  },
  
  playbooks: {
    structure: [
      'situation_overview',
      'target_persona',
      'key_messages',
      'discovery_questions',
      'demo_flow',
      'objection_responses',
      'next_steps'
    ],
    updateTrigger: ['messaging_change', 'new_feature', 'icp_shift'],
    format: 'google_doc'
  },
  
  trainingModules: {
    structure: [
      'learning_objectives',
      'key_concepts',
      'real_examples',
      'practice_scenarios',
      'quiz_questions',
      'certification_criteria'
    ],
    updateTrigger: ['product_launch', 'process_change', 'quarterly'],
    format: 'interactive_html'
  },
  
  oneSheets: {
    structure: [
      'headline_value_prop',
      'key_benefits',
      'proof_points',
      'call_to_action'
    ],
    updateTrigger: ['campaign_launch', 'messaging_refresh'],
    format: 'figma_template'
  }
};

// enablement-agent.js
const { Codex } = require('@openai/codex');

const enablementAgent = new Codex({
  model: 'gpt-5.3-codex',
  tools: ['file_read', 'file_write', 'web_search', 'api_call'],
  context: `You are a Sales Enablement Content Generator.

Your job is to create and update sales training materials that help reps win more deals.

SOURCES OF TRUTH:
- Product documentation: /docs/product/
- Competitive intel: /docs/competitive/
- Win/loss reports: /crm/win-loss/
- Customer stories: /docs/customers/
- Pricing: /docs/pricing/

CONTENT PRINCIPLES:
1. Be specific and actionable—no generic fluff
2. Include real customer examples when available
3. Anticipate rep questions and objections
4. Make content scannable (bullets > paragraphs)
5. Include talk tracks reps can use verbatim

VOICE:
- Confident but not arrogant
- Data-driven with proof points
- Conversational, not corporate`
});

async function generateBattleCard(competitor) {
  // Gather fresh intel
  const competitorData = await gatherCompetitorIntel(competitor);
  const recentWins = await getWinsAgainst(competitor);
  const recentLosses = await getLossesTo(competitor);
  
  const battleCard = await enablementAgent.run(`
    Generate a sales battle card for ${competitor}.
    
    COMPETITOR DATA:
    ${JSON.stringify(competitorData, null, 2)}
    
    RECENT WINS AGAINST THEM (last 90 days):
    ${JSON.stringify(recentWins, null, 2)}
    
    RECENT LOSSES TO THEM (last 90 days):
    ${JSON.stringify(recentLosses, null, 2)}
    
    Generate the battle card with these sections:
    
    ## Quick Stats
    - Founded, HQ, funding, employee count
    - Key customers
    - Pricing (if known)
    
    ## Where They Win
    - Their genuine strengths (be honest)
    - Types of deals they tend to win
    
    ## Where We Win
    - Our differentiators vs them
    - Types of deals we tend to win
    
    ## Landmines to Plant
    - Questions that expose their weaknesses
    - Features to emphasize in demos
    
    ## Objection Handlers
    For each common objection, provide:
    - Objection
    - Response framework
    - Proof point to cite
    
    ## Talk Track
    A 30-second positioning statement when ${competitor} comes up
    
    ## Customer Wins
    Specific stories of customers who chose us over them
  `);
  
  return battleCard;
}

async function generateTrainingModule(topic, config) {
  const module = await enablementAgent.run(`
    Create an interactive sales training module on: ${topic}
    
    Target audience: ${config.audience}
    Estimated completion time: ${config.duration} minutes
    Prerequisites: ${config.prerequisites.join(', ')}
    
    Generate as HTML with embedded interactivity:
    
    1. LEARNING OBJECTIVES
    - What will they be able to do after this module?
    
    2. CORE CONTENT
    - Break into 3-5 digestible sections
    - Include real examples from our customer base
    - Add "Try This" interactive elements
    
    3. SCENARIO PRACTICE
    - 3 realistic scenarios they might encounter
    - Multiple choice responses with feedback
    - Explain why correct answers work
    
    4. TALK TRACK BUILDER
    - Interactive section where they build their own pitch
    - Template with fill-in-the-blank sections
    - Example completed version
    
    5. QUIZ
    - 5 questions testing key concepts
    - Mix of multiple choice and short answer
    - Passing score: 80%
    
    6. RESOURCES
    - Links to related content
    - Cheat sheet for quick reference
    - Who to ask for help
    
    Output as a complete, styled HTML document that can be hosted in our LMS.
  `);
  
  return module;
}

async function createPlaybookWithFeedback(playbookType) {
  // Start generation
  const session = await enablementAgent.startTask(`
    Create a sales playbook for: ${playbookType}
    Start with discovery questions.
  `);
  
  // Review first section
  const discoverySection = await session.checkpoint();
  console.log('Discovery section:', discoverySection);
  
  // Steer based on review
  await session.steer(`
    Good start, but:
    - Add more questions about budget timing
    - Include a question about competitive evaluation
    - Make questions more open-ended
  `);
  
  // Continue with refinements
  await session.continue();
  
  // Final output
  return session.complete();
}

// content-updater.js

// Trigger: Competitor releases new feature
async function onCompetitorUpdate(competitor, update) {
  const affectedContent = await findContentMentioning(competitor);
  
  for (const content of affectedContent) {
    const updated = await enablementAgent.run(`
      Update this content to reflect new competitor information:
      
      ORIGINAL CONTENT:
      ${content.body}
      
      NEW INFORMATION:
      ${competitor} just ${update.summary}
      
      Details: ${update.details}
      
      Update the content to:
      1. Reflect any new competitive threats
      2. Update our positioning if needed
      3. Add new objection handlers if relevant
      4. Keep the same format and structure
      
      Return only the updated content.
    `);
    
    await saveContent(content.id, updated);
    await notifyEnablement(`Updated ${content.title} based on ${competitor} news`);
  }
}

// Trigger: Product team ships feature
async function onProductUpdate(feature) {
  // Update relevant playbooks
  const playbooks = await findPlaybooksForFeature(feature.area);
  
  for (const playbook of playbooks) {
    await enablementAgent.run(`
      Add information about our new feature to this playbook:
      
      NEW FEATURE: ${feature.name}
      DESCRIPTION: ${feature.description}
      KEY BENEFITS: ${feature.benefits.join(', ')}
      TARGET PERSONA: ${feature.persona}
      
      CURRENT PLAYBOOK:
      ${playbook.body}
      
      Updates needed:
      1. Add feature to "What We Offer" section
      2. Create demo talking points
      3. Add discovery questions that surface need for this feature
      4. Update objection handlers if this addresses known concerns
    `);
  }
  
  // Create training module for new feature
  await generateTrainingModule(`New Feature: ${feature.name}`, {
    audience: 'all-sales',
    duration: 15,
    prerequisites: ['product-fundamentals']
  });
}

async function validateContent(content, type) {
  const validation = await enablementAgent.run(`
    Validate this ${type} against our quality standards:
    
    CONTENT:
    ${content}
    
    CHECK FOR:
    1. ✓ Specificity — Are claims backed by data/examples?
    2. ✓ Accuracy — Do features/pricing match current product?
    3. ✓ Actionability — Can a rep use this immediately?
    4. ✓ Scannability — Is it easy to skim?
    5. ✓ Completeness — Are all required sections present?
    6. ✓ Freshness — Are examples and data current?
    7. ✓ Voice — Does it match our brand tone?
    
    Return:
    {
      "score": 0-100,
      "issues": ["list of specific problems"],
      "suggestions": ["how to fix each issue"],
      "approved": true/false
    }
  `);
  
  return JSON.parse(validation);
}

async function publishToSeismic(content) {
  const formatted = await enablementAgent.run(`
    Format this content for Seismic upload:
    ${content}
    
    - Add proper metadata tags
    - Set appropriate permissions (sales-team)
    - Include search keywords
    - Add related content suggestions
  `);
  
  await seismic.content.create({
    title: formatted.title,
    body: formatted.body,
    tags: formatted.tags,
    permissions: ['sales-team'],
    keywords: formatted.keywords
  });
}

// Slack command: /enablement-request
app.command('/enablement-request', async ({ command, ack, respond }) => {
  await ack();
  
  const request = command.text;
  
  // Quick triage
  const triage = await enablementAgent.run(`
    Triage this enablement request:
    "${request}"
    
    Determine:
    1. Content type needed (battle card, playbook, training, etc.)
    2. Priority (urgent, normal, nice-to-have)
    3. Can this be auto-generated or needs human input?
    4. Estimated time to create
  `);
  
  if (triage.canAutoGenerate) {
    const content = await generateContent(triage.contentType, request);
    await respond(`✅ Created! Here's your ${triage.contentType}: ${content.url}`);
  } else {
    await createEnablementTicket(request, triage);
    await respond(`📋 Request logged. Enablement team will review.`);
  }
});

// webhooks/zoom.js
const express = require('express');
const { OpenClaw } = require('openclaw');

const app = express();
const openclaw = new OpenClaw();

app.post('/webhooks/zoom', async (req, res) => {
  const { event, payload } = req.body;
  
  if (event === 'recording.completed') {
    const { download_url, meeting_id, topic, start_time } = payload.object;
    
    // Trigger the transcription pipeline
    await openclaw.trigger('meeting-processor', {
      recordingUrl: download_url,
      meetingId: meeting_id,
      title: topic,
      timestamp: start_time,
      source: 'zoom'
    });
  }
  
  res.sendStatus(200);
});

app.listen(3000);

// watchers/local-recordings.js
const chokidar = require('chokidar');
const { OpenClaw } = require('openclaw');

const openclaw = new OpenClaw();
const RECORDINGS_DIR = '/path/to/recordings';

const watcher = chokidar.watch(RECORDINGS_DIR, {
  ignored: /(^|[\/\\])\../,
  persistent: true,
  awaitWriteFinish: true
});

watcher.on('add', async (filePath) => {
  if (filePath.endsWith('.mp4') || filePath.endsWith('.m4a')) {
    console.log(`📹 New recording detected: ${filePath}`);
    
    await openclaw.trigger('meeting-processor', {
      filePath,
      title: path.basename(filePath, path.extname(filePath)),
      timestamp: new Date().toISOString(),
      source: 'local'
    });
  }
});

console.log(`👀 Watching ${RECORDINGS_DIR} for new recordings...`);

// lib/transcribe.js
const fs = require('fs');
const FormData = require('form-data');

async function transcribeAudio(audioPath) {
  const form = new FormData();
  form.append('file', fs.createReadStream(audioPath));
  form.append('model', 'whisper-1');
  form.append('response_format', 'verbose_json');
  form.append('language', 'en');
  
  const response = await fetch('https://api.openai.com/v1/audio/transcriptions', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`,
      ...form.getHeaders()
    },
    body: form
  });
  
  const result = await response.json();
  
  return {
    text: result.text,
    segments: result.segments, // Includes timestamps
    duration: result.duration
  };
}

module.exports = { transcribeAudio };

// lib/transcribe-local.js
const { exec } = require('child_process');
const util = require('util');
const execAsync = util.promisify(exec);

async function transcribeLocal(audioPath) {
  const outputPath = audioPath.replace(/\.[^/.]+$/, '');
  
  await execAsync(
    `whisper "${audioPath}" --model medium --output_format json --output_dir /tmp`
  );
  
  const transcript = require(`${outputPath}.json`);
  
  return {
    text: transcript.text,
    segments: transcript.segments,
    duration: transcript.segments[transcript.segments.length - 1]?.end || 0
  };
}

module.exports = { transcribeLocal };

// lib/analyze.js
const Anthropic = require('@anthropic-ai/sdk');

const client = new Anthropic();

async function analyzeTranscript(transcript, metadata) {
  const response = await client.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 4000,
    messages: [{
      role: 'user',
      content: `Analyze this sales call transcript.
      
Meeting: ${metadata.title}
Date: ${metadata.timestamp}
Duration: ${metadata.duration} minutes
Attendees: ${metadata.attendees?.join(', ') || 'Unknown'}

---TRANSCRIPT---
${transcript}
---END TRANSCRIPT---`
    }]
  });

  return parseAnalysis(response.content[0].text);
}

function parseAnalysis(rawAnalysis) {
  // Parse the structured output into a JSON object
  const sections = {};
  
  const sectionPatterns = [
    { key: 'summary', pattern: /### SUMMARY\n([\s\S]*?)(?=###|$)/ },
    { key: 'keyPoints', pattern: /### KEY DISCUSSION POINTS\n([\s\S]*?)(?=###|$)/ },
    { key: 'painPoints', pattern: /### CUSTOMER PAIN POINTS\n([\s\S]*?)(?=###|$)/ },
    { key: 'buyingSignals', pattern: /### BUYING SIGNALS\n([\s\S]*?)(?=###|$)/ },
    { key: 'objections', pattern: /### OBJECTIONS\/CONCERNS\n([\s\S]*?)(?=###|$)/ },
    { key: 'competition', pattern: /### COMPETITION MENTIONED\n([\s\S]*?)(?=###|$)/ },
    { key: 'actionItems', pattern: /### ACTION ITEMS\n([\s\S]*?)(?=###|$)/ },
    { key: 'dealStage', pattern: /### DEAL STAGE RECOMMENDATION\n([\s\S]*?)(?=###|$)/ },
    { key: 'priority', pattern: /### FOLLOW-UP PRIORITY\n([\s\S]*?)(?=###|$)/ },
    { key: 'coaching', pattern: /### COACHING NOTES\n([\s\S]*?)(?=###|$)/ }
  ];
  
  sectionPatterns.forEach(({ key, pattern }) => {
    const match = rawAnalysis.match(pattern);
    sections[key] = match ? match[1].trim() : '';
  });
  
  return sections;
}

module.exports = { analyzeTranscript };

// lib/crm-sync.js
const HubSpot = require('@hubspot/api-client');

const hubspot = new HubSpot.Client({ accessToken: process.env.HUBSPOT_TOKEN });

async function syncToHubSpot(dealId, analysis, recordingUrl) {
  // Create engagement (call note)
  const noteBody = `
## Meeting Summary
${analysis.summary}

## Key Points
${analysis.keyPoints}

## Pain Points Identified
${analysis.painPoints}

## Buying Signals
${analysis.buyingSignals}

## Action Items
${analysis.actionItems}

---
🎥 [View Recording](${recordingUrl})
📊 Priority: ${analysis.priority}
🎯 Suggested Stage: ${analysis.dealStage}
`;

  // Create note
  await hubspot.crm.objects.notes.basicApi.create({
    properties: {
      hs_note_body: noteBody,
      hs_timestamp: Date.now()
    },
    associations: [{
      to: { id: dealId },
      types: [{ associationCategory: 'HUBSPOT_DEFINED', associationTypeId: 214 }]
    }]
  });

  // Update deal stage if recommended
  const stageMap = {
    'Discovery': 'appointmentscheduled',
    'Qualification': 'qualifiedtobuy',
    'Demo/Evaluation': 'presentationscheduled',
    'Negotiation': 'contractsent'
  };
  
  const newStage = stageMap[analysis.dealStage.trim()];
  if (newStage) {
    await hubspot.crm.deals.basicApi.update(dealId, {
      properties: { dealstage: newStage }
    });
  }

  // Create tasks for action items
  const actionItems = parseActionItems(analysis.actionItems);
  for (const item of actionItems) {
    await hubspot.crm.objects.tasks.basicApi.create({
      properties: {
        hs_task_body: item.task,
        hs_task_subject: `Follow-up: ${item.task.substring(0, 50)}...`,
        hs_task_status: 'NOT_STARTED',
        hs_task_priority: analysis.priority.includes('High') ? 'HIGH' : 'MEDIUM',
        hs_timestamp: Date.now()
      }
    });
  }
}

function parseActionItems(actionItemsText) {
  const items = [];
  const lines = actionItemsText.split('\n').filter(l => l.trim().startsWith('[ ]'));
  
  lines.forEach(line => {
    const match = line.match(/\[ \] ([^:]+): (.+)/);
    if (match) {
      items.push({ owner: match[1].trim(), task: match[2].trim() });
    }
  });
  
  return items;
}

module.exports = { syncToHubSpot };

// lib/notify.js
async function sendSlackNotification(channel, analysis, meetingInfo) {
  const blocks = [
    {
      type: 'header',
      text: {
        type: 'plain_text',
        text: `📞 Call Analyzed: ${meetingInfo.title}`
      }
    },
    {
      type: 'section',
      text: {
        type: 'mrkdwn',
        text: `*Summary:* ${analysis.summary}`
      }
    },
    {
      type: 'section',
      fields: [
        {
          type: 'mrkdwn',
          text: `*Priority:* ${analysis.priority.split('\n')[0]}`
        },
        {
          type: 'mrkdwn',
          text: `*Stage:* ${analysis.dealStage.split('\n')[0]}`
        }
      ]
    },
    {
      type: 'section',
      text: {
        type: 'mrkdwn',
        text: `*Buying Signals:*\n${analysis.buyingSignals.substring(0, 500)}`
      }
    },
    {
      type: 'section',
      text: {
        type: 'mrkdwn',
        text: `*Action Items:*\n${analysis.actionItems.substring(0, 500)}`
      }
    },
    {
      type: 'actions',
      elements: [
        {
          type: 'button',
          text: { type: 'plain_text', text: '🎥 View Recording' },
          url: meetingInfo.recordingUrl
        },
        {
          type: 'button',
          text: { type: 'plain_text', text: '📊 View Deal' },
          url: `https://app.hubspot.com/contacts/deals/${meetingInfo.dealId}`
        }
      ]
    }
  ];

  await fetch(process.env.SLACK_WEBHOOK_URL, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ blocks })
  });
}

module.exports = { sendSlackNotification };

// data-sources.js

// HubSpot CRM
async function getHubSpotPipeline() {
  const deals = await hubspot.crm.deals.getAll({
    properties: [
      'dealname', 'amount', 'dealstage', 'closedate',
      'pipeline', 'hs_forecast_amount', 'hubspot_owner_id'
    ],
    associations: ['companies', 'contacts']
  });
  
  return deals.filter(d => 
    d.properties.pipeline === 'default' &&
    d.properties.closedate >= startOfQuarter()
  );
}

// Salesforce
async function getSalesforcePipeline() {
  const deals = await salesforce.query(`
    SELECT Id, Name, Amount, StageName, CloseDate, 
           ForecastCategory, OwnerId, Account.Name
    FROM Opportunity
    WHERE CloseDate >= THIS_QUARTER
    AND IsClosed = false
  `);
  
  return deals.records;
}

// Data warehouse (for historical data)
async function getHistoricalMetrics(period) {
  const result = await bigquery.query(`
    SELECT 
      DATE_TRUNC(close_date, WEEK) as week,
      SUM(amount) as closed_won,
      COUNT(*) as deals_closed,
      AVG(sales_cycle_days) as avg_cycle
    FROM sales.opportunities
    WHERE close_date >= DATE_SUB(CURRENT_DATE(), INTERVAL ${period} DAY)
    AND stage = 'Closed Won'
    GROUP BY 1
    ORDER BY 1
  `);
  
  return result.rows;
}

// report-generator.js
const Anthropic = require('@anthropic-ai/sdk');
const claude = new Anthropic();

async function generateWeeklyReport() {
  // Gather all data
  const pipeline = await getHubSpotPipeline();
  const historical = await getHistoricalMetrics(90);
  const repMetrics = await getRepPerformance();
  
  // Calculate key metrics
  const metrics = {
    totalPipeline: sumPipeline(pipeline),
    forecastedClose: sumForecast(pipeline),
    pipelineChange: calculateWoWChange(pipeline),
    topDeals: getTopDeals(pipeline, 5),
    atRisk: getAtRiskDeals(pipeline),
    closedThisWeek: getClosedDeals('this-week'),
    repLeaderboard: calculateLeaderboard(repMetrics)
  };
  
  // Generate narrative with Claude
  const narrative = await claude.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 2048,
    messages: [{
      role: 'user',
      content: `Generate the executive summary for our weekly sales report.

CURRENT METRICS:
${JSON.stringify(metrics, null, 2)}

HISTORICAL CONTEXT:
${JSON.stringify(historical, null, 2)}

Write a 3-4 paragraph executive summary that:
1. Highlights the most important number (good or bad)
2. Explains what changed this week and why
3. Calls out deals that need attention
4. Ends with a forward-looking statement

Be direct and specific. Executives don't want fluff.
If numbers are concerning, say so clearly.
Include specific rep names and deal names when relevant.`
    }]
  });
  
  return {
    metrics,
    narrative: narrative.content[0].text,
    generatedAt: new Date().toISOString()
  };
}

async function formatForAudience(report, audience) {
  const formats = {
    'cro': {
      sections: ['executive_summary', 'forecast_vs_target', 'top_deals', 'risks'],
      detail: 'high-level',
      length: 'short'
    },
    'sales-managers': {
      sections: ['team_performance', 'rep_leaderboard', 'coaching_opportunities', 'deals_needing_help'],
      detail: 'medium',
      length: 'medium'
    },
    'sales-ops': {
      sections: ['full_pipeline', 'data_quality_issues', 'process_bottlenecks', 'forecasting_accuracy'],
      detail: 'granular',
      length: 'detailed'
    },
    'board': {
      sections: ['arr_progress', 'quota_attainment', 'key_wins', 'market_trends'],
      detail: 'strategic',
      length: 'concise'
    }
  };
  
  const config = formats[audience];
  
  const formatted = await claude.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 4096,
    messages: [{
      role: 'user',
      content: `Format this sales report for ${audience}:

RAW REPORT:
${JSON.stringify(report, null, 2)}

FORMAT CONFIG:
- Sections to include: ${config.sections.join(', ')}
- Detail level: ${config.detail}
- Length: ${config.length}

Output as clean markdown suitable for Slack or email.
Use tables where appropriate.
Bold key numbers.`
    }]
  });
  
  return formatted.content[0].text;
}

async function deliverToSlack(report, channel, audience) {
  const formatted = await formatForAudience(report, audience);
  
  await slack.postMessage({
    channel: channel,
    text: `📊 Weekly Sales Report - ${formatDate(new Date())}`,
    blocks: [
      {
        type: 'header',
        text: { type: 'plain_text', text: `📊 Weekly Sales Report` }
      },
      {
        type: 'section',
        fields: [
          { type: 'mrkdwn', text: `*Total Pipeline:*\n$${(report.metrics.totalPipeline / 1e6).toFixed(1)}M` },
          { type: 'mrkdwn', text: `*Forecast:*\n$${(report.metrics.forecastedClose / 1e6).toFixed(1)}M` },
          { type: 'mrkdwn', text: `*WoW Change:*\n${report.metrics.pipelineChange > 0 ? '↑' : '↓'} ${Math.abs(report.metrics.pipelineChange)}%` },
          { type: 'mrkdwn', text: `*Closed This Week:*\n$${(report.metrics.closedThisWeek / 1e3).toFixed(0)}K` }
        ]
      },
      {
        type: 'section',
        text: { type: 'mrkdwn', text: `*Executive Summary*\n${report.narrative}` }
      },
      {
        type: 'divider'
      },
      {
        type: 'section',
        text: { type: 'mrkdwn', text: `*Top 5 Deals to Watch*\n${formatTopDeals(report.metrics.topDeals)}` }
      },
      {
        type: 'actions',
        elements: [
          { type: 'button', text: { type: 'plain_text', text: 'Full Report' }, url: report.fullReportUrl },
          { type: 'button', text: { type: 'plain_text', text: 'Pipeline Dashboard' }, url: report.dashboardUrl }
        ]
      }
    ]
  });
}