WhatsApp User → WhatsApp API → Webhook → Your Server → CRM API
     ↑                                        ↓
     └────────── WhatsApp API ←── Your Server ←┘

// server.js — WhatsApp webhook receiver
const express = require('express');
const app = express();
app.use(express.json());

const RAPIDAPI_KEY = process.env.RAPIDAPI_KEY;
const RAPIDAPI_HOST = 'whatsapp-messaging-bot.p.rapidapi.com';

// Store for conversation context
const conversations = new Map();

app.post('/webhook/whatsapp', async (req, res) => {
  const { event, payload } = req.body;
  
  console.log(`📩 Received event: ${event}`);
  
  if (event === 'message') {
    const { from, body, timestamp } = payload;
    const phoneNumber = from.replace('@c.us', '');
    
    console.log(`💬 Message from ${phoneNumber}: ${body}`);
    
    // Route to CRM integration
    await handleIncomingMessage(phoneNumber, body, timestamp);
  }
  
  res.status(200).json({ status: 'ok' });
});

async function handleIncomingMessage(phone, message, timestamp) {
  // Step 1: Check if contact exists in CRM
  let contact = await findCRMContact(phone);
  
  // Step 2: Create contact if new
  if (!contact) {
    contact = await createCRMContact(phone, message);
    console.log(`✅ New CRM contact created: ${phone}`);
  }
  
  // Step 3: Log the message in CRM
  await logMessageInCRM(contact.id, message, 'inbound', timestamp);
  
  // Step 4: Trigger CRM automation
  await triggerCRMAutomation(contact, message);
}

app.listen(3000, () => console.log('🚀 Webhook server running on port 3000'));

// hubspot-integration.js
const HUBSPOT_TOKEN = process.env.HUBSPOT_ACCESS_TOKEN;

async function findHubSpotContact(phone) {
  const response = await fetch(
    `https://api.hubapi.com/crm/v3/objects/contacts/search`,
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        Authorization: `Bearer ${HUBSPOT_TOKEN}`,
      },
      body: JSON.stringify({
        filterGroups: [{
          filters: [{
            propertyName: 'phone',
            operator: 'EQ',
            value: phone,
          }],
        }],
      }),
    }
  );
  
  const data = await response.json();
  return data.total > 0 ? data.results[0] : null;
}

async function createHubSpotContact(phone, firstMessage) {
  const response = await fetch(
    'https://api.hubapi.com/crm/v3/objects/contacts',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        Authorization: `Bearer ${HUBSPOT_TOKEN}`,
      },
      body: JSON.stringify({
        properties: {
          phone: phone,
          firstname: 'WhatsApp Lead',
          lifecyclestage: 'lead',
          hs_lead_status: 'NEW',
          // Custom property for WhatsApp
          whatsapp_first_message: firstMessage,
          whatsapp_opted_in: 'true',
        },
      }),
    }
  );
  
  return await response.json();
}

async function logHubSpotNote(contactId, message, direction, timestamp) {
  const noteBody = direction === 'inbound'
    ? `📥 WhatsApp message received:\n\n"${message}"`
    : `📤 WhatsApp message sent:\n\n"${message}"`;
  
  await fetch(
    'https://api.hubapi.com/crm/v3/objects/notes',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        Authorization: `Bearer ${HUBSPOT_TOKEN}`,
      },
      body: JSON.stringify({
        properties: {
          hs_note_body: noteBody,
          hs_timestamp: new Date(timestamp).toISOString(),
        },
        associations: [{
          to: { id: contactId },
          types: [{ associationCategory: 'HUBSPOT_DEFINED', associationTypeId: 202 }],
        }],
      }),
    }
  );
}

async function createHubSpotDeal(contactId, dealName, amount) {
  const deal = await fetch(
    'https://api.hubapi.com/crm/v3/objects/deals',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        Authorization: `Bearer ${HUBSPOT_TOKEN}`,
      },
      body: JSON.stringify({
        properties: {
          dealname: dealName,
          amount: amount,
          dealstage: 'appointmentscheduled',
          pipeline: 'default',
          whatsapp_source: 'true',
        },
        associations: [{
          to: { id: contactId },
          types: [{ associationCategory: 'HUBSPOT_DEFINED', associationTypeId: 3 }],
        }],
      }),
    }
  );
  
  return await deal.json();
}

// salesforce-integration.js
const SF_INSTANCE_URL = process.env.SF_INSTANCE_URL;
const SF_ACCESS_TOKEN = process.env.SF_ACCESS_TOKEN;

async function sfQuery(soql) {
  const response = await fetch(
    `${SF_INSTANCE_URL}/services/data/v59.0/query?q=${encodeURIComponent(soql)}`,
    {
      headers: { Authorization: `Bearer ${SF_ACCESS_TOKEN}` },
    }
  );
  return await response.json();
}

async function findSalesforceContact(phone) {
  // Search by phone number across Contacts and Leads
  const result = await sfQuery(
    `SELECT Id, Name, Phone, Email FROM Contact WHERE Phone = '${phone}' LIMIT 1`
  );
  
  if (result.totalSize > 0) return result.records[0];
  
  // Check Leads too
  const leadResult = await sfQuery(
    `SELECT Id, Name, Phone, Email FROM Lead WHERE Phone = '${phone}' LIMIT 1`
  );
  
  return leadResult.totalSize > 0 ? leadResult.records[0] : null;
}

async function createSalesforceLead(phone, message) {
  const response = await fetch(
    `${SF_INSTANCE_URL}/services/data/v59.0/sobjects/Lead`,
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        Authorization: `Bearer ${SF_ACCESS_TOKEN}`,
      },
      body: JSON.stringify({
        LastName: `WhatsApp Lead (${phone})`,
        Phone: phone,
        LeadSource: 'WhatsApp',
        Status: 'New',
        Description: `First message: ${message}`,
      }),
    }
  );
  
  return await response.json();
}

async function logSalesforceTask(contactId, message, direction) {
  await fetch(
    `${SF_INSTANCE_URL}/services/data/v59.0/sobjects/Task`,
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        Authorization: `Bearer ${SF_ACCESS_TOKEN}`,
      },
      body: JSON.stringify({
        WhoId: contactId,
        Subject: `WhatsApp ${direction === 'inbound' ? 'Received' : 'Sent'}`,
        Description: message,
        Status: 'Completed',
        Priority: 'Normal',
        Type: 'WhatsApp',
      }),
    }
  );
}

// pipedrive-integration.js
const PIPEDRIVE_TOKEN = process.env.PIPEDRIVE_API_TOKEN;
const PIPEDRIVE_URL = `https://api.pipedrive.com/v1`;

async function findPipedriveContact(phone) {
  const response = await fetch(
    `${PIPEDRIVE_URL}/persons/search?term=${phone}&api_token=${PIPEDRIVE_TOKEN}`
  );
  const data = await response.json();
  return data.data?.items?.[0]?.item || null;
}

async function createPipedriveContact(phone, message) {
  const response = await fetch(
    `${PIPEDRIVE_URL}/persons?api_token=${PIPEDRIVE_TOKEN}`,
    {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        name: `WhatsApp Lead (${phone})`,
        phone: [{ value: phone, primary: true }],
        // Add to "WhatsApp Leads" label
        label: 1,
      }),
    }
  );
  
  return await response.json();
}

async function createPipedriveDeal(personId, title) {
  await fetch(
    `${PIPEDRIVE_URL}/deals?api_token=${PIPEDRIVE_TOKEN}`,
    {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        title: title,
        person_id: personId,
        stage_id: 1, // First stage of pipeline
      }),
    }
  );
}

async function logPipedriveNote(personId, message, direction) {
  const emoji = direction === 'inbound' ? '📥' : '📤';
  
  await fetch(
    `${PIPEDRIVE_URL}/notes?api_token=${PIPEDRIVE_TOKEN}`,
    {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        content: `${emoji} <strong>WhatsApp ${direction}</strong><br><br>${message}`,
        person_id: personId,
      }),
    }
  );
}

// send-whatsapp.js
async function sendWhatsAppMessage(phone, text) {
  const response = await fetch(
    'https://whatsapp-messaging-bot.p.rapidapi.com/api/v1/messages/sendText',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'X-RapidAPI-Key': process.env.RAPIDAPI_KEY,
        'X-RapidAPI-Host': 'whatsapp-messaging-bot.p.rapidapi.com',
      },
      body: JSON.stringify({
        session: 'default',
        to: phone,
        text: text,
      }),
    }
  );
  
  const result = await response.json();
  console.log(`📤 Message sent to ${phone}`);
  return result;
}

// Automated follow-up sequences
async function sendFollowUpSequence(contact) {
  const sequences = {
    new_lead: [
      { delay: 0, message: `Hi ${contact.name}! Thanks for reaching out. How can we help you today?` },
      { delay: 24 * 60, message: `Hi ${contact.name}, just following up. Did you have a chance to look at our offerings? Happy to answer any questions!` },
      { delay: 72 * 60, message: `Hi ${contact.name}, I noticed you showed interest in our product. Would you like to schedule a quick demo? It takes just 15 minutes.` },
    ],
    demo_booked: [
      { delay: 0, message: `Great! Your demo is confirmed for ${contact.demoDate}. Looking forward to it! 📅` },
      { delay: -60, message: `Reminder: Your demo starts in 1 hour. Here's the meeting link: ${contact.meetingLink}` },
    ],
  };
  
  const sequence = sequences[contact.stage] || sequences.new_lead;
  
  for (const step of sequence) {
    if (step.delay === 0) {
      await sendWhatsAppMessage(contact.phone, step.message);
    } else {
      // Schedule for later (use your preferred scheduler)
      scheduleMessage(contact.phone, step.message, step.delay);
    }
  }
}

// qualification-bot.js
const qualificationQuestions = [
  { key: 'budget', question: "What's your approximate monthly budget for this solution?", options: ['Under $100', '$100-$500', '$500-$2000', '$2000+'] },
  { key: 'timeline', question: 'When are you looking to implement?', options: ['This week', 'This month', 'Next quarter', 'Just researching'] },
  { key: 'team_size', question: 'How large is your team?', options: ['Just me', '2-10', '11-50', '50+'] },
];

async function handleQualification(contact, message) {
  const state = conversations.get(contact.phone) || { step: 0, answers: {} };
  
  if (state.step < qualificationQuestions.length) {
    const currentQ = qualificationQuestions[state.step];
    
    // Save answer
    state.answers[currentQ.key] = message;
    state.step++;
    
    if (state.step < qualificationQuestions.length) {
      // Ask next question
      const nextQ = qualificationQuestions[state.step];
      const optionsList = nextQ.options.map((o, i) => `${i + 1}. ${o}`).join('\n');
      
      await sendWhatsAppMessage(
        contact.phone,
        `${nextQ.question}\n\n${optionsList}\n\nReply with the number of your choice.`
      );
    } else {
      // Qualification complete — update CRM
      await updateCRMQualification(contact, state.answers);
      
      await sendWhatsAppMessage(
        contact.phone,
        `Thanks for the info! I'm connecting you with a specialist who can help. They'll reach out shortly. 🚀`
      );
    }
    
    conversations.set(contact.phone, state);
  }
}

async function updateCRMQualification(contact, answers) {
  // Calculate lead score
  const scoreMap = {
    budget: { 'Under $100': 1, '$100-$500': 2, '$500-$2000': 3, '$2000+': 4 },
    timeline: { 'This week': 4, 'This month': 3, 'Next quarter': 2, 'Just researching': 1 },
    team_size: { 'Just me': 1, '2-10': 2, '11-50': 3, '50+': 4 },
  };
  
  let score = 0;
  for (const [key, value] of Object.entries(answers)) {
    score += scoreMap[key]?.[value] || 0;
  }
  
  // Update HubSpot (or your CRM)
  await fetch(
    `https://api.hubapi.com/crm/v3/objects/contacts/${contact.id}`,
    {
      method: 'PATCH',
      headers: {
        'Content-Type': 'application/json',
        Authorization: `Bearer ${process.env.HUBSPOT_ACCESS_TOKEN}`,
      },
      body: JSON.stringify({
        properties: {
          hs_lead_status: score >= 8 ? 'QUALIFIED' : 'IN_PROGRESS',
          whatsapp_lead_score: String(score),
          whatsapp_budget: answers.budget,
          whatsapp_timeline: answers.timeline,
          whatsapp_team_size: answers.team_size,
        },
      }),
    }
  );
}

FROM node:20-slim
WORKDIR /app
COPY package*.json ./
RUN npm ci --omit=dev
COPY . .
EXPOSE 3000
CMD ["node", "server.js"]

# WhatsApp API
RAPIDAPI_KEY=your_key
RAPIDAPI_HOST=whatsapp-messaging-bot.p.rapidapi.com
WHATSAPP_SESSION=crm-bot

# CRM (choose one)
HUBSPOT_ACCESS_TOKEN=pat-xxx
# SF_INSTANCE_URL=https://yourorg.my.salesforce.com
# SF_ACCESS_TOKEN=xxx
# PIPEDRIVE_API_TOKEN=xxx

# Server
PORT=3000
WEBHOOK_SECRET=your_webhook_secret