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

const rfpAgent = new Codex({
  model: 'gpt-5.3-codex',
  tools: ['file_read', 'file_write', 'search'],
  context: `You are an expert RFP response writer. Your job is to:
  1. Parse RFP questions accurately
  2. Find matching answers in the library
  3. Draft responses that are professional and specific
  4. Flag questions that need human review
  
  Always maintain the company's professional tone.
  Never make up technical claims—flag for review if unsure.`
});

async function processRFP(rfpDocument) {
  // Extract questions from RFP
  const questions = await rfpAgent.run(`
    Parse this RFP document and extract all questions.
    Return as JSON array with:
    - question_id
    - question_text
    - category (security/technical/company/pricing/other)
    - complexity (simple/moderate/complex)
    
    Document: ${rfpDocument}
  `);
  
  // Match each question to library
  for (const q of questions) {
    const match = await rfpAgent.run(`
      Find the best matching answer in our library for:
      "${q.question_text}"
      
      Return:
      - matched_file
      - confidence (0-100)
      - suggested_response
      - needs_review (boolean)
    `);
    
    q.match = match;
  }
  
  return questions;
}

// Start processing
const session = await rfpAgent.startTask(`
  Process RFP section on data security.
  Draft responses for questions 15-25.
`);

// Mid-turn steering when you notice issues
await session.steer(`
  Important context: This client is in healthcare.
  Emphasize HIPAA compliance in all security answers.
  Reference our healthcare customer case studies.
`);

// Continue processing with new context
const results = await session.complete();

async function enrichFromCRM(rfpDocument, dealId) {
  const deal = await hubspot.deals.get(dealId);
  
  return rfpAgent.run(`
    Process this RFP with the following context:
    - Company: ${deal.company.name}
    - Industry: ${deal.company.industry}
    - Deal Size: ${deal.amount}
    - Key Requirements: ${deal.properties.requirements}
    
    Customize responses accordingly.
    Document: ${rfpDocument}
  `);
}

async function notifyTeam(rfpResults) {
  const needsReview = rfpResults.filter(q => q.needs_review);
  
  if (needsReview.length > 0) {
    await slack.postMessage({
      channel: '#rfp-team',
      text: `🔔 RFP "${rfpName}" needs review on ${needsReview.length} questions`,
      blocks: needsReview.map(q => ({
        type: 'section',
        text: `*Q${q.question_id}:* ${q.question_text}\n_Confidence: ${q.confidence}%_`
      }))
    });
  }
}

async function calculateCommission(deal, repProfile) {
  const prompt = `
    Calculate commission for this deal:
    
    DEAL:
    - Company: ${deal.company}
    - ACV: $${deal.acv}
    - Type: ${deal.type} (New/Expansion/Renewal)
    - Products: ${deal.products.join(', ')}
    - Contract term: ${deal.termMonths} months
    - Close date: ${deal.closeDate}
    - Displaced competitor: ${deal.displacedCompetitor || 'None'}
    
    REP:
    - Name: ${repProfile.name}
    - Role: ${repProfile.role}
    - Quota: $${repProfile.quota}
    - YTD Closed: $${repProfile.ytdClosed}
    - Current attainment: ${repProfile.attainment}%
    
    OTHER PARTIES ON DEAL:
    ${deal.splits.map(s => `- ${s.name} (${s.role}): ${s.contribution}`).join('\n')}
    
    Show all calculations step by step.
  `;
  
  return await claude.calculate(prompt);
}

async function runMonthlyCommissions(month, year) {
  // Get all closed deals
  const deals = await crm.getClosedDeals({ month, year });
  
  // Get all rep profiles
  const reps = await getRepProfiles();
  
  // Calculate each deal
  const commissions = [];
  for (const deal of deals) {
    const calc = await calculateCommission(deal, reps[deal.ownerId]);
    commissions.push({
      deal: deal,
      calculation: calc,
      breakdown: parseBreakdown(calc)
    });
  }
  
  // Check for clawbacks
  const clawbacks = await checkClawbacks(month, year);
  
  // Generate report
  return {
    totalPayout: sum(commissions.map(c => c.breakdown.finalAmount)),
    byRep: groupByRep(commissions),
    clawbacks: clawbacks,
    flaggedForReview: commissions.filter(c => c.breakdown.hasFlags)
  };
}

async function repCommissionQuery(repId, question) {
  const repProfile = await getRepProfile(repId);
  const recentDeals = await getRecentDeals(repId);
  const commissionHistory = await getCommissionHistory(repId);
  
  const prompt = `
    A sales rep is asking about their commission.
    
    REP PROFILE:
    ${JSON.stringify(repProfile)}
    
    RECENT DEALS:
    ${JSON.stringify(recentDeals)}
    
    COMMISSION HISTORY (Last 3 months):
    ${JSON.stringify(commissionHistory)}
    
    QUESTION:
    ${question}
    
    Answer clearly, show relevant calculations, reference 
    specific deals and comp plan provisions.
  `;
  
  return await claude.answer(prompt);
}

async function modelPlanChange(proposedChange, historicalDeals) {
  const prompt = `
    We're considering this comp plan change:
    "${proposedChange}"
    
    Analyze the impact using last quarter's deals:
    ${JSON.stringify(historicalDeals)}
    
    Show:
    1. Total payout difference (old plan vs new)
    2. Impact per rep
    3. Which deal types are affected most
    4. Potential unintended consequences
    5. Recommendation
  `;
  
  return await claude.analyze(prompt);
}

async function processClawbacks() {
  // Find churned customers
  const churns = await crm.getChurns({ lookbackMonths: 12 });
  
  for (const churn of churns) {
    // Find original commission
    const originalCommission = await findCommission(churn.dealId);
    
    // Calculate clawback
    const monthsSinceDeal = monthsBetween(
      originalCommission.closeDate, 
      churn.churnDate
    );
    
    let clawbackRate;
    if (monthsSinceDeal <= 6) clawbackRate = 1.0;
    else if (monthsSinceDeal <= 12) clawbackRate = 0.5;
    else clawbackRate = 0;
    
    if (clawbackRate > 0) {
      await createClawback({
        repId: originalCommission.repId,
        dealId: churn.dealId,
        amount: originalCommission.amount * clawbackRate,
        reason: `Customer churned at ${monthsSinceDeal} months`
      });
    }
  }
}

const qualityChecks = [
  { name: 'length', check: email => email.length < 800 },
  { name: 'personalization', check: email => containsProspectDetails(email) },
  { name: 'cta_present', check: email => hasCallToAction(email) },
  { name: 'no_forbidden_words', check: email => !containsForbidden(email) },
  { name: 'sentiment_positive', check: email => scoreSentiment(email) > 0.5 }
];

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 };