const prospectContext = {
  company: "TechCorp Industries",
  size: "200 employees",
  industry: "Manufacturing IoT",
  currentTool: "Salesforce + manual prospecting",
  painPoints: ["slow lead response", "inconsistent outreach"],
  dealSize: "$45,000 ARR",
  competitorsMentioned: ["Apollo", "ZoomInfo"]
};

const objection = "We're already using Apollo — why would we switch?";

// Claude processes with full context
const response = await claude.complete({
  prompt: `
    Prospect context: ${JSON.stringify(prospectContext)}
    Objection: "${objection}"
    
    Generate objection handling responses.
  `,
  system: OBJECTION_HANDLER_PROMPT
});

const OBJECTION_CATEGORIES = [
  { id: 'price', patterns: ['too expensive', 'budget', 'cost', 'cheaper', 'price'], severity: 'high' },
  { id: 'timing', patterns: ['not right now', 'next quarter', 'not ready', 'too soon'], severity: 'medium' },
  { id: 'competition', patterns: ['looking at', 'comparing', 'competitor', 'other options'], severity: 'high' },
  { id: 'authority', patterns: ['need to talk to', 'not my decision', 'get approval', 'run it by'], severity: 'medium' },
  { id: 'trust', patterns: ['never heard of', 'new company', 'references', 'case studies'], severity: 'low' },
  { id: 'status_quo', patterns: ['we\'re fine', 'not broken', 'current solution works', 'happy with'], severity: 'high' },
  { id: 'urgency', patterns: ['think about it', 'get back to you', 'need time', 'not urgent'], severity: 'critical' }
];

async function detectObjection(transcript) {
  // First pass: pattern matching for speed
  for (const category of OBJECTION_CATEGORIES) {
    const pattern = new RegExp(category.patterns.join('|'), 'i');
    if (pattern.test(transcript.latestUtterance)) {
      return { detected: true, category: category.id, severity: category.severity };
    }
  }
  
  // Second pass: AI classification for nuanced objections
  const classification = await claude.messages.create({
    model: 'claude-3-5-sonnet-20241022',
    max_tokens: 200,
    messages: [{
      role: 'user',
      content: `Is this an objection? If so, classify it:
      
      "${transcript.latestUtterance}"
      
      Categories: price, timing, competition, authority, trust, status_quo, urgency, none
      
      Output JSON: { "isObjection": boolean, "category": string, "severity": "low"|"medium"|"high"|"critical" }`
    }]
  });
  
  return JSON.parse(classification.content[0].text);
}

async function gatherObjectionContext(dealId, objection) {
  // Get deal and contact info
  const deal = await crm.getDeal(dealId);
  const contact = await crm.getContact(deal.primaryContactId);
  const company = await crm.getCompany(deal.companyId);
  
  // Get conversation history
  const previousCalls = await crm.getCallNotes(dealId);
  const emails = await crm.getEmails(dealId);
  
  // Find similar objections that were overcome
  const successfulHandles = await objectionDb.find({
    category: objection.category,
    industry: company.industry,
    outcome: 'overcome'
  });
  
  // Get competitor intel if competition objection
  let competitorIntel = null;
  if (objection.category === 'competition') {
    const mentioned = extractCompetitorMentions(previousCalls);
    competitorIntel = await getCompetitorBattlecards(mentioned);
  }
  
  return {
    deal,
    contact,
    company,
    conversationHistory: [...previousCalls, ...emails],
    successfulHandles,
    competitorIntel,
    currentCallTranscript: objection.transcript
  };
}

async function generateObjectionResponse(objection, context) {
  const systemPrompt = `You are a world-class sales coach generating 
real-time objection handling scripts. Your responses:

1. ACKNOWLEDGE the concern (don't dismiss or argue)
2. CLARIFY to understand the real issue
3. RESPOND with context-specific evidence
4. ADVANCE toward next steps

Guidelines:
- Keep total response under 30 seconds of speaking time (~75 words)
- Use the prospect's exact language when possible
- Reference specific things from their situation
- Include one concrete data point or example
- End with a question that moves forward

NEVER:
- Sound scripted or robotic
- Use generic platitudes
- Argue or get defensive
- Ignore the emotional component`;

  const response = await claude.messages.create({
    model: 'claude-3-5-sonnet-20241022',
    max_tokens: 500,
    system: systemPrompt,
    messages: [{
      role: 'user',
      content: `Generate an objection response for this situation:

OBJECTION CATEGORY: ${objection.category}
EXACT WORDS: "${objection.exactPhrase}"

PROSPECT CONTEXT:
- Name: ${context.contact.name}
- Title: ${context.contact.title}
- Company: ${context.company.name} (${context.company.industry})
- Company Size: ${context.company.employeeCount}
- Deal Value: $${context.deal.amount}

CONVERSATION CONTEXT:
- Stage: ${context.deal.stage}
- Days in pipeline: ${context.deal.daysInPipeline}
- Previous objections overcome: ${context.conversationHistory.filter(c => c.objectionOvercome).length}

${context.competitorIntel ? `COMPETITOR MENTIONED: ${context.competitorIntel.name}
Key Differentiator: ${context.competitorIntel.primaryDifferentiator}` : ''}

SUCCESSFUL HANDLES FOR SIMILAR SITUATIONS:
${context.successfulHandles.slice(0, 2).map(h => 
  `- "${h.objection}" → Response: "${h.response}" → Outcome: ${h.outcome}`
).join('\n')}

Generate a natural, conversational response the rep can use RIGHT NOW.`
    }]
  });
  
  return {
    script: response.content[0].text,
    category: objection.category,
    followUpQuestions: await generateFollowUps(objection, context),
    resources: await findRelevantResources(objection, context)
  };
}

// Option 1: Screen overlay
async function overlayDelivery(response, sessionId) {
  await callAssistant.showOverlay(sessionId, {
    type: 'objection_response',
    category: response.category,
    script: response.script,
    followUps: response.followUpQuestions,
    ttl: 60000 // Visible for 60 seconds
  });
}

// Option 2: Slack whisper
async function slackDelivery(response, repId) {
  await slack.sendDM(repId, {
    text: `🎯 *Objection Detected: ${response.category}*\n\n${response.script}`,
    attachments: [{
      title: 'Follow-up Questions',
      text: response.followUpQuestions.join('\n• ')
    }]
  });
}

// Option 3: Voice whisper (for phone calls)
async function voiceWhisper(response, callSessionId) {
  // Text-to-speech through the rep's earpiece
  await twilio.whisper(callSessionId, {
    text: `Objection: ${response.category}. Try: ${response.script.substring(0, 100)}`,
    voice: 'concise'
  });
}

const PRICE_TEMPLATE = {
  pattern: /too expensive|budget|cost|price/i,
  contextQuestions: [
    'What other solutions were they comparing to?',
    'What\'s their current spend on this problem?',
    'Who else is involved in budget decisions?'
  ],
  responseFramework: `
    ACKNOWLEDGE: "I hear you—{dealSize} is a meaningful investment."
    
    CLARIFY: "Help me understand: is it that the total cost is higher than 
    expected, or that you're not yet seeing how the ROI justifies it?"
    
    RESPOND (if ROI unclear): "Companies like {similarCustomer} in \{industry\} 
    typically see {specificROI} within {timeframe}. For your team of 
    {teamSize}, that translates to roughly {calculatedSavings}."
    
    RESPOND (if truly budget-constrained): "I appreciate the transparency. 
    A few options: We could start with {reducedScope} at {lowerPrice}, or 
    structure payments {alternativePayment}. What works better for your 
    planning cycles?"
    
    ADVANCE: "What would you need to see to feel confident this pays for 
    itself within {paybackPeriod}?"
  `
};

const STATUS_QUO_TEMPLATE = {
  pattern: /we're fine|not broken|current solution works|happy with/i,
  contextQuestions: [
    'What are they currently using?',
    'How long have they been using it?',
    'What triggered this conversation in the first place?'
  ],
  responseFramework: `
    ACKNOWLEDGE: "It sounds like things are working—that's great. 
    Most of our best customers weren't in crisis mode either."
    
    CLARIFY: "I'm curious though—you took this meeting for a reason. 
    Was there something specific that made you want to explore alternatives?"
    
    RESPOND: "The companies that wait for things to break usually find 
    the switch costs 3-4x more because they're doing it under pressure. 
    {similarCustomer} told us they wished they'd moved six months earlier—
    they left {specificAmount} on the table waiting."
    
    ADVANCE: "What would 'good enough' need to become 'not good enough' 
    for you to prioritize this?"
  `
};

const STALL_TEMPLATE = {
  pattern: /think about it|get back to you|need time|not urgent/i,
  contextQuestions: [
    'What specific concerns haven\'t been addressed?',
    'Who else needs to be involved?',
    'What\'s their actual timeline?'
  ],
  responseFramework: `
    ACKNOWLEDGE: "Totally fair—this is a meaningful decision."
    
    CLARIFY: "When you say you need to think about it, is it more about 
    {option1: 'getting alignment with others'}, {option2: 'comparing to 
    other options'}, or {option3: 'making sure it fits the budget'}?"
    
    RESPOND (alignment): "Who else needs to weigh in? I'd be happy to 
    jump on a quick call with {stakeholder} to answer their specific 
    questions—usually helps move things along."
    
    RESPOND (comparison): "What specifically are you hoping the other 
    options offer that you haven't seen from us? I want to make sure 
    you have what you need to compare apples to apples."
    
    RESPOND (budget): [See price objection framework]
    
    ADVANCE: "I want to be respectful of your time—can we schedule a 
    brief check-in for {specific date} to see where things stand? 
    That way you have time to think, and I can answer any questions 
    that come up."
  `
};

async function logObjectionOutcome(objectionId, outcome, repFeedback) {
  await objectionDb.update(objectionId, {
    outcome: outcome, // 'overcome', 'stalled', 'lost'
    repFeedback: repFeedback,
    scriptUsed: true
  });
  
  // If successful, boost similar responses
  if (outcome === 'overcome') {
    const objection = await objectionDb.get(objectionId);
    await updateSuccessWeights({
      category: objection.category,
      industry: objection.industry,
      dealSize: objection.dealSize,
      response: objection.generatedScript
    });
  }
}

// Use success data to improve future generations
async function getWeightedExamples(category, context) {
  const examples = await objectionDb.find({
    category,
    industry: context.company.industry,
    dealSizeRange: getDealSizeRange(context.deal.amount),
    outcome: 'overcome'
  });
  
  // Sort by success rate and recency
  return examples
    .sort((a, b) => b.successScore - a.successScore)
    .slice(0, 5);
}

// Gong webhook for real-time transcription
app.post('/webhooks/gong/transcript', async (req, res) => {
  const { callId, transcript, speakerSegments } = req.body;
  
  // Get latest prospect utterance
  const prospectSegments = speakerSegments.filter(s => s.speaker === 'prospect');
  const latestUtterance = prospectSegments[prospectSegments.length - 1];
  
  // Check for objection
  const objection = await detectObjection({
    latestUtterance: latestUtterance.text,
    fullTranscript: transcript
  });
  
  if (objection.detected) {
    const dealId = await crm.getDealByCallId(callId);
    const context = await gatherObjectionContext(dealId, objection);
    const response = await generateObjectionResponse(objection, context);
    
    // Deliver to rep
    const rep = await getRepByCallId(callId);
    await overlayDelivery(response, rep.sessionId);
  }
  
  res.sendStatus(200);
});

// weekly-forecast.js
const forecast = await runForecastModel();

const summary = `
## Pipeline Forecast - Week of ${today}

**Predicted Q1 Close:** $${forecast.totalExpectedValue.toLocaleString()}
**High-Confidence Deals:** ${forecast.highConfidence.length}
**At-Risk Deals:** ${forecast.atRisk.length}

### Top 5 Likely Closes
${forecast.topDeals.map(d => 
  `- ${d.name}: $${d.amount} (${d.probability}%)`
).join('\n')}

### Deals Needing Attention
${forecast.atRisk.map(d => 
  `- ${d.name}: ${d.risk_factors[0]}`
).join('\n')}
`;

await slack.send({ channel: "#sales-leadership", message: summary });

async function gatherProposalContext(dealId) {
  // Get CRM data
  const deal = await hubspot.getDeal(dealId, {
    associations: ['contacts', 'companies', 'meetings', 'notes']
  });
  
  // Get company info
  const company = deal.associations.companies[0];
  const companyData = {
    name: company.name,
    industry: company.industry,
    size: company.numberOfEmployees,
    revenue: company.annualRevenue,
    website: company.website,
    description: company.description
  };
  
  // Get meeting transcripts/notes
  const meetingNotes = deal.associations.meetings.map(m => ({
    date: m.meetingDate,
    notes: m.notes,
    attendees: m.attendees
  }));
  
  // Get relevant case studies from our database
  const caseStudies = await findRelevantCaseStudies({
    industry: company.industry,
    companySize: company.numberOfEmployees
  });
  
  // Get product/pricing info
  const productInfo = await getProductCatalog();
  const pricingTiers = await getPricingForDealSize(deal.amount);
  
  // Compile competitors mentioned
  const competitorMentions = extractCompetitorMentions(meetingNotes);
  
  return {
    deal,
    company: companyData,
    meetings: meetingNotes,
    caseStudies,
    products: productInfo,
    pricing: pricingTiers,
    competitors: competitorMentions
  };
}

const PROPOSAL_SYSTEM_PROMPT = `
You are an expert B2B sales proposal writer. Your proposals have an 
exceptional win rate because you:

1. Lead with the prospect's specific pain points, using their exact language
2. Connect each capability to measurable business outcomes
3. Include relevant social proof (similar company size, industry)
4. Present pricing as an investment with clear ROI
5. Make next steps frictionless

STYLE GUIDELINES:
- Write in confident but not arrogant tone
- Use "you" and "your" heavily (prospect-focused)
- Avoid jargon unless the prospect used it first
- Keep sentences punchy—average 15 words
- Use numbers and specifics over generalities

FORMATTING:
- Output as JSON matching the Proposal interface
- Include 2-3 case studies maximum
- Provide 2-3 pricing options (good/better/best)
- Keep executive summary under 200 words
`;

async function generateProposal(context) {
  const response = await claude.messages.create({
    model: 'claude-3-5-sonnet-20241022',
    max_tokens: 8000,
    system: PROPOSAL_SYSTEM_PROMPT,
    messages: [{
      role: 'user',
      content: `Generate a proposal for the following opportunity:

PROSPECT COMPANY:
${JSON.stringify(context.company, null, 2)}

DEAL CONTEXT:
- Deal Size: $${context.deal.amount}
- Stage: ${context.deal.stage}
- Products of Interest: ${context.deal.products?.join(', ')}

MEETING NOTES (Discovery Insights):
${context.meetings.map(m => `
[${m.date}]
${m.notes}
`).join('\n---\n')}

AVAILABLE CASE STUDIES:
${JSON.stringify(context.caseStudies, null, 2)}

PRICING TIERS:
${JSON.stringify(context.pricing, null, 2)}

${context.competitors.length > 0 ? `
COMPETITORS MENTIONED:
${context.competitors.join(', ')}
(Address differentiators tactfully)
` : ''}

Generate a complete, personalized proposal.`
    }],
    response_format: { type: 'json_object' }
  });
  
  return JSON.parse(response.content[0].text);
}

async function renderProposal(proposalData, outputFormat = 'docx') {
  switch (outputFormat) {
    case 'docx':
      return await renderToWord(proposalData);
    case 'pdf':
      return await renderToPDF(proposalData);
    case 'slides':
      return await renderToSlides(proposalData);
    case 'notion':
      return await renderToNotion(proposalData);
    default:
      return proposalData; // Return raw JSON
  }
}

async function renderToWord(proposal) {
  const doc = new Document({
    sections: [{
      properties: {},
      children: [
        // Cover page
        new Paragraph({
          children: [
            new TextRun({
              text: `Proposal for ${proposal.metadata.prospectCompany}`,
              bold: true,
              size: 48
            })
          ],
          alignment: 'center'
        }),
        
        // Executive Summary
        new Paragraph({
          children: [
            new TextRun({ text: 'Executive Summary', bold: true, size: 32 })
          ]
        }),
        new Paragraph({
          children: [
            new TextRun({ text: proposal.executiveSummary.headline, bold: true })
          ]
        }),
        ...proposal.executiveSummary.painPointsSummary.map(point => 
          new Paragraph({ children: [new TextRun(`• ${point}`)] })
        ),
        
        // ... continue for all sections
      ]
    }]
  });
  
  return await Packer.toBuffer(doc);
}

async function generateMultiStakeholderProposal(context) {
  const stakeholders = context.meetings
    .flatMap(m => m.attendees)
    .filter(a => a.role !== 'our_team');
  
  // Identify personas
  const personas = await claude.analyze({
    messages: [{
      role: 'user',
      content: `Categorize these stakeholders:
                ${JSON.stringify(stakeholders)}
                
                Categories: Executive, Finance, Technical, End-User`
    }]
  });
  
  // Generate proposal with persona-specific sections
  return generateProposal({
    ...context,
    stakeholderPersonas: personas,
    additionalInstructions: `
      Include these targeted sections:
      - Executive Summary (for ${personas.executive?.name})
      - Technical Specifications (for ${personas.technical?.name})
      - ROI Analysis (for ${personas.finance?.name})
    `
  });
}

if (context.competitors.includes('competitor-x')) {
  context.additionalInstructions += `
    The prospect mentioned evaluating Competitor X. Include:
    - A brief, factual comparison (no FUD)
    - Differentiation on the specific pain points they mentioned
    - A case study of a customer who switched from Competitor X
    
    Keep comparison professional—never bash the competitor.
  `;
}

if (context.deal.customPricingRequested) {
  const customPricing = await calculateCustomPricing({
    baseSeats: context.deal.seatCount,
    addOns: context.deal.requestedAddOns,
    term: context.deal.contractTerm,
    volume: context.company.numberOfEmployees
  });
  
  context.pricing = {
    custom: true,
    breakdown: customPricing,
    flexibility: 'Pricing reflects your specific requirements. Let\'s discuss if anything needs adjustment.'
  };
}

// HubSpot workflow trigger
app.post('/webhooks/hubspot/deal-stage-change', async (req, res) => {
  const { dealId, newStage } = req.body;
  
  if (newStage === 'proposal_requested') {
    // Gather context
    const context = await gatherProposalContext(dealId);
    
    // Generate proposal
    const proposal = await generateProposal(context);
    
    // Render to PDF
    const pdf = await renderProposal(proposal, 'pdf');
    
    // Save to deal
    await hubspot.uploadFile(dealId, pdf, 'proposal.pdf');
    
    // Notify rep
    await slack.notify(context.deal.owner, {
      text: `📄 Proposal generated for ${context.company.name}`,
      actions: [
        { text: 'Review', url: `https://app.hubspot.com/deals/${dealId}` },
        { text: 'Send to Prospect', callback: 'send_proposal' }
      ]
    });
  }
  
  res.sendStatus(200);
});

async function queueForReview(proposal, dealId) {
  // Create review task
  await hubspot.createTask({
    dealId,
    subject: 'Review Generated Proposal',
    priority: 'HIGH',
    notes: `AI-generated proposal is ready for review.
            
            Check:
            - [ ] Pain points accurately captured
            - [ ] Pricing correct
            - [ ] Case studies relevant
            - [ ] No copy/paste errors
            
            Make edits directly in the attached document.`,
    dueDate: addHours(new Date(), 4)
  });
}