mkdir whatsapp-support-bot
cd whatsapp-support-bot
npm init -y
npm install axios express dotenv pg sequelize openai

RAPIDAPI_KEY=your_rapidapi_key_here
RAPIDAPI_HOST=whatsapp-messaging-bot.p.rapidapi.com
WHATSAPP_SESSION=support-bot

DATABASE_URL=postgresql://user:password@localhost:5432/support_db
OPENAI_API_KEY=sk-your-openai-key-here

# Help desk integration (optional)
ZENDESK_SUBDOMAIN=yourcompany
ZENDESK_EMAIL=support@yourcompany.com
ZENDESK_API_TOKEN=your_token_here

// models/SupportTicket.js
const { Sequelize, DataTypes } = require('sequelize');
const sequelize = new Sequelize(process.env.DATABASE_URL);

const SupportTicket = sequelize.define('SupportTicket', {
  id: {
    type: DataTypes.UUID,
    defaultValue: DataTypes.UUIDV4,
    primaryKey: true
  },
  customerPhone: {
    type: DataTypes.STRING,
    allowNull: false
  },
  customerName: {
    type: DataTypes.STRING
  },
  issue: {
    type: DataTypes.TEXT,
    allowNull: false
  },
  intent: {
    type: DataTypes.STRING // 'shipping', 'refund', 'technical', 'billing', etc.
  },
  status: {
    type: DataTypes.ENUM('new', 'bot_handled', 'escalated', 'resolved', 'closed'),
    defaultValue: 'new'
  },
  priority: {
    type: DataTypes.ENUM('low', 'medium', 'high', 'urgent'),
    defaultValue: 'medium'
  },
  resolvedBy: {
    type: DataTypes.ENUM('bot', 'human', 'hybrid'),
    defaultValue: 'bot'
  },
  botConfidence: {
    type: DataTypes.FLOAT // 0.0 to 1.0
  },
  zendeskTicketId: {
    type: DataTypes.STRING // Link to help desk
  },
  resolutionTime: {
    type: DataTypes.INTEGER // seconds
  },
  conversationHistory: {
    type: DataTypes.JSON,
    defaultValue: []
  }
});

const Message = sequelize.define('Message', {
  id: {
    type: DataTypes.UUID,
    defaultValue: DataTypes.UUIDV4,
    primaryKey: true
  },
  ticketId: {
    type: DataTypes.UUID,
    references: {
      model: SupportTicket,
      key: 'id'
    }
  },
  sender: {
    type: DataTypes.ENUM('customer', 'bot', 'agent')
  },
  message: {
    type: DataTypes.TEXT
  },
  timestamp: {
    type: DataTypes.DATE,
    defaultValue: DataTypes.NOW
  }
});

// Relationships
SupportTicket.hasMany(Message, { foreignKey: 'ticketId' });
Message.belongsTo(SupportTicket, { foreignKey: 'ticketId' });

module.exports = { SupportTicket, Message, sequelize };

// whatsapp-client.js
const axios = require('axios');
require('dotenv').config();

class WhatsAppClient {
  constructor() {
    this.baseURL = `https://${process.env.RAPIDAPI_HOST}`;
    this.session = process.env.WHATSAPP_SESSION;
    this.headers = {
      'X-RapidAPI-Key': process.env.RAPIDAPI_KEY,
      'X-RapidAPI-Host': process.env.RAPIDAPI_HOST,
      'Content-Type': 'application/json'
    };
  }

  async sendMessage(phoneNumber, message) {
    try {
      const response = await axios.post(
        `${this.baseURL}/v1/sendText`,
        {
          chatId: phoneNumber.replace(/\\D/g, ''),
          text: message,
          session: this.session
        },
        { headers: this.headers }
      );
      
      console.log(`✅ Message sent to ${phoneNumber}`);
      return response.data;
    } catch (error) {
      console.error('Error sending message:', error.response?.data || error.message);
      throw error;
    }
  }

  async sendMessageWithButtons(phoneNumber, text, buttons) {
    // Note: Interactive buttons are not supported in this API version
    // Send as plain text with options listed
    try {
      const buttonText = buttons.map((btn, i) => `${i + 1}. ${btn.text}`).join('\n');
      const fullText = `${text}\n\n${buttonText}\n\nReply with the number of your choice.`;
      
      const response = await axios.post(
        `${this.baseURL}/v1/sendText`,
        {
          chatId: phoneNumber.replace(/\\D/g, ''),
          text: fullText,
          session: this.session
        },
        { headers: this.headers }
      );
      
      return response.data;
    } catch (error) {
      console.error('Error sending buttons:', error.response?.data || error.message);
      throw error;
    }
  }

  async setupWebhook(webhookUrl) {
    try {
      await axios.post(
        `${this.baseURL}/v1/sessions/${this.session}/webhook`,
        { url: webhookUrl },
        { headers: this.headers }
      );
      
      console.log(`✅ Webhook set to ${webhookUrl}`);
    } catch (error) {
      console.error('Error setting webhook:', error.response?.data || error.message);
      throw error;
    }
  }
}

module.exports = WhatsAppClient;

// intent-classifier.js
class IntentClassifier {
  constructor() {
    // Define intent patterns (keywords that indicate intent)
    this.intents = {
      shipping: {
        keywords: ['shipping', 'delivery', 'track', 'tracking', 'order status', 'where is my order', 'wimo', 'shipment', 'arrived', 'deliver'],
        responses: [
          'I can help you track your order! Please provide your order number (e.g., #12345).',
          'To check your shipping status, I need your order number. It starts with # and is in your confirmation email.'
        ]
      },
      refund: {
        keywords: ['refund', 'return', 'money back', 'cancel order', 'cancellation', 'dispute', 'chargeback'],
        responses: [
          'I understand you want to process a refund. Our refund policy allows returns within 30 days. What's your order number?',
          'I can help with returns and refunds. Please share your order number so I can look into this for you.'
        ]
      },
      technical: {
        keywords: ['not working', 'broken', 'error', 'bug', 'issue', 'problem', 'crash', 'freeze', 'login', 'password'],
        responses: [
          'I'm sorry you're experiencing technical issues. Can you describe what's happening in more detail?',
          'Let's troubleshoot this together. What error message are you seeing, if any?'
        ]
      },
      billing: {
        keywords: ['billing', 'charge', 'payment', 'invoice', 'receipt', 'credit card', 'charged twice', 'unauthorized'],
        responses: [
          'I can help with billing questions. What specific billing issue are you experiencing?',
          'For billing inquiries, please provide your account email or order number.'
        ]
      },
      account: {
        keywords: ['account', 'login', 'password', 'reset', 'forgot password', 'locked out', 'username', 'email change'],
        responses: [
          'I can help with account issues. What do you need help with? (login, password reset, account info)',
          'For account support, please confirm: What email is associated with your account?'
        ]
      },
      product_info: {
        keywords: ['product', 'features', 'specs', 'specifications', 'how does', 'what is', 'tell me about', 'size', 'color', 'availability'],
        responses: [
          'I'd be happy to provide product information! Which product are you interested in?',
          'What would you like to know about our products? I can share details on features, pricing, and availability.'
        ]
      },
      greeting: {
        keywords: ['hi', 'hello', 'hey', 'good morning', 'good afternoon', 'good evening', 'help', 'support'],
        responses: [
          `👋 Hello! Welcome to our support team. I'm here 24/7 to help.\n\nHow can I assist you today?\n\n📦 Track order\n💰 Refund/return\n🔧 Technical issue\n💳 Billing question\n👤 Account help\n📱 Product info`,
          `Hi there! I'm your AI support assistant. I can help you with:\n\n• Order tracking & shipping\n• Returns & refunds\n• Technical support\n• Billing questions\n• Account issues\n\nWhat do you need help with?`
        ]
      }
    };
  }

  classifyIntent(message) {
    const lowerMessage = message.toLowerCase();
    let bestMatch = { intent: 'unknown', confidence: 0 };

    for (const [intent, data] of Object.entries(this.intents)) {
      let matchCount = 0;
      
      for (const keyword of data.keywords) {
        if (lowerMessage.includes(keyword.toLowerCase())) {
          matchCount++;
        }
      }
      
      const confidence = matchCount / data.keywords.length;
      
      if (confidence > bestMatch.confidence) {
        bestMatch = { intent, confidence, responses: data.responses };
      }
    }

    // Threshold: require at least 10% keyword match
    if (bestMatch.confidence < 0.1) {
      return { intent: 'unknown', confidence: 0 };
    }

    return bestMatch;
  }

  getRandomResponse(responses) {
    return responses[Math.floor(Math.random() * responses.length)];
  }
}

module.exports = IntentClassifier;

// ai-engine.js
const OpenAI = require('openai');
require('dotenv').config();

class AIEngine {
  constructor() {
    this.openai = new OpenAI({
      apiKey: process.env.OPENAI_API_KEY
    });
    
    // Knowledge base (in production, load from database)
    this.knowledgeBase = `
You are a customer support AI assistant for [YourCompany]. 

COMPANY INFO:
- We sell consumer electronics and accessories
- Standard shipping takes 3-5 business days
- Express shipping available (1-2 business days)
- 30-day return policy (full refund if unused)
- Customer service hours: 9 AM - 6 PM EST Mon-Fri
- Website: yourcompany.com
- Support email: support@yourcompany.com

POLICIES:
1. Refunds: Full refund within 30 days if product is unused and in original packaging
2. Shipping: Free shipping on orders $50+
3. Warranty: 1-year manufacturer warranty on all electronics
4. Price Match: We match competitor prices (with proof)

COMMON ISSUES:
- Password reset: Go to yourcompany.com/forgot-password
- Track order: Enter order number at yourcompany.com/track
- Update shipping address: Contact support before order ships

TONE:
- Friendly, professional, empathetic
- Keep responses concise (2-3 sentences max)
- Always offer to escalate to human agent if issue is complex
- End with "Is there anything else I can help you with?"
    `.trim();
  }

  async generateResponse(userMessage, intent, conversationHistory = []) {
    try {
      const messages = [
        {
          role: 'system',
          content: this.knowledgeBase
        },
        ...conversationHistory.map(msg => ({
          role: msg.sender === 'customer' ? 'user' : 'assistant',
          content: msg.message
        })),
        {
          role: 'user',
          content: userMessage
        }
      ];

      const response = await this.openai.chat.completions.create({
        model: 'gpt-4',
        messages: messages,
        max_tokens: 200,
        temperature: 0.7
      });

      const aiResponse = response.choices[0].message.content;
      const confidence = this.calculateConfidence(response);

      return {
        response: aiResponse,
        confidence: confidence
      };
    } catch (error) {
      console.error('AI Engine error:', error.message);
      return {
        response: null,
        confidence: 0
      };
    }
  }

  calculateConfidence(response) {
    // Simple confidence calculation based on response
    // In production, use more sophisticated methods
    const finishReason = response.choices[0].finish_reason;
    
    if (finishReason === 'stop') {
      return 0.85; // High confidence
    } else if (finishReason === 'length') {
      return 0.6; // Medium confidence (response was cut off)
    } else {
      return 0.3; // Low confidence
    }
  }
}

module.exports = AIEngine;

// support-bot.js
const WhatsAppClient = require('./whatsapp-client');
const IntentClassifier = require('./intent-classifier');
const AIEngine = require('./ai-engine');
const { SupportTicket, Message } = require('./models/SupportTicket');

class SupportBot {
  constructor() {
    this.whatsapp = new WhatsAppClient();
    this.intentClassifier = new IntentClassifier();
    this.aiEngine = new AIEngine();
    this.escalationThreshold = 0.5; // Confidence below this = escalate to human
  }

  async handleIncomingMessage(phoneNumber, message, customerName = 'Customer') {
    console.log(`📨 New message from ${phoneNumber}: ${message}`);

    try {
      // 1. Find or create support ticket
      let ticket = await SupportTicket.findOne({
        where: {
          customerPhone: phoneNumber,
          status: ['new', 'bot_handled', 'escalated']
        }
      });

      if (!ticket) {
        ticket = await SupportTicket.create({
          customerPhone: phoneNumber,
          customerName: customerName,
          issue: message,
          status: 'new'
        });
      }

      // 2. Log message
      await Message.create({
        ticketId: ticket.id,
        sender: 'customer',
        message: message
      });

      // 3. Classify intent
      const intentResult = this.intentClassifier.classifyIntent(message);
      console.log(`🎯 Intent: ${intentResult.intent} (confidence: ${intentResult.confidence.toFixed(2)})`);

      // Update ticket intent
      await ticket.update({ intent: intentResult.intent });

      let response;
      let confidence = intentResult.confidence;

      // 4. Generate response
      if (intentResult.intent === 'greeting' || intentResult.confidence > 0.3) {
        // Use keyword-based response for high-confidence intents
        response = this.intentClassifier.getRandomResponse(intentResult.responses);
      } else {
        // Use AI for complex or unknown queries
        const conversationHistory = await Message.findAll({
          where: { ticketId: ticket.id },
          order: [['timestamp', 'ASC']],
          limit: 10 // Last 10 messages for context
        });

        const aiResult = await this.aiEngine.generateResponse(
          message,
          intentResult.intent,
          conversationHistory.map(m => ({ sender: m.sender, message: m.message }))
        );

        response = aiResult.response;
        confidence = aiResult.confidence;
      }

      // 5. Escalate if confidence is low
      if (confidence < this.escalationThreshold && intentResult.intent !== 'greeting') {
        await this.escalateToHuman(ticket, phoneNumber, message);
        return;
      }

      // 6. Send response
      await this.whatsapp.sendMessage(phoneNumber, response);

      // 7. Log bot response
      await Message.create({
        ticketId: ticket.id,
        sender: 'bot',
        message: response
      });

      // 8. Update ticket
      await ticket.update({
        status: 'bot_handled',
        botConfidence: confidence,
        resolvedBy: 'bot'
      });

      console.log(`✅ Bot responded with confidence: ${confidence.toFixed(2)}`);

    } catch (error) {
      console.error('Error handling message:', error);
      
      // Fallback response
      await this.whatsapp.sendMessage(
        phoneNumber,
        `I'm having trouble processing your request right now. A human agent will assist you shortly. Your ticket number is #${ticket?.id?.substring(0, 8)}.`
      );
    }
  }

  async escalateToHuman(ticket, phoneNumber, message) {
    console.log(`⚠️ Escalating ticket ${ticket.id} to human agent`);

    // Update ticket status
    await ticket.update({
      status: 'escalated',
      priority: 'high'
    });

    // Notify customer
    const escalationMessage = `
🙋 I'm connecting you with a human support agent who can better assist with your specific issue.

📞 **Options:**
1. Continue here - An agent will respond within 15 minutes
2. Call us: 1-800-123-4567 (Mon-Fri 9AM-6PM EST)
3. Email: support@yourcompany.com

Your ticket number: #${ticket.id.substring(0, 8)}

Thank you for your patience! 🙏
    `.trim();

    await this.whatsapp.sendMessage(phoneNumber, escalationMessage);

    // Create ticket in help desk (e.g., Zendesk)
    await this.createZendeskTicket(ticket, phoneNumber, message);

    // Notify internal team (Slack, email, etc.)
    await this.notifyTeam(ticket, phoneNumber, message);
  }

  async createZendeskTicket(ticket, phoneNumber, message) {
    // Example Zendesk integration
    // In production, use Zendesk SDK
    const axios = require('axios');

    try {
      const zendeskResponse = await axios.post(
        `https://${process.env.ZENDESK_SUBDOMAIN}.zendesk.com/api/v2/tickets`,
        {
          ticket: {
            subject: `WhatsApp Support - ${ticket.intent || 'General inquiry'}`,
            comment: {
              body: `Customer: ${ticket.customerName || 'Unknown'}\\nPhone: ${phoneNumber}\\n\\nMessage:\\n${message}\\n\\nIntent: ${ticket.intent}\\nBot Confidence: ${ticket.botConfidence}`
            },
            priority: ticket.priority,
            tags: ['whatsapp', 'bot-escalation', ticket.intent]
          }
        },
        {
          auth: {
            username: `${process.env.ZENDESK_EMAIL}/token`,
            password: process.env.ZENDESK_API_TOKEN
          }
        }
      );

      await ticket.update({
        zendeskTicketId: zendeskResponse.data.ticket.id
      });

      console.log(`✅ Zendesk ticket created: ${zendeskResponse.data.ticket.id}`);
    } catch (error) {
      console.error('Error creating Zendesk ticket:', error.message);
    }
  }

  async notifyTeam(ticket, phoneNumber, message) {
    // Notify team via Slack, email, or SMS
    // Example: Send to Slack webhook
    console.log(`🔔 Team notified about escalated ticket ${ticket.id}`);
  }
}

module.exports = SupportBot;

// server.js
const express = require('express');
const bodyParser = require('body-parser');
const SupportBot = require('./support-bot');
const { sequelize } = require('./models/SupportTicket');

const app = express();
app.use(bodyParser.json());

const supportBot = new SupportBot();

// Webhook endpoint to receive incoming WhatsApp messages
app.post('/webhook/whatsapp', async (req, res) => {
  try {
    const { chatId, message, sender } = req.body;
    
    // Ignore messages sent by the bot itself
    if (sender === 'bot') {
      return res.sendStatus(200);
    }

    // Handle incoming customer message
    await supportBot.handleIncomingMessage(chatId, message, sender);

    res.sendStatus(200);
  } catch (error) {
    console.error('Webhook error:', error);
    res.sendStatus(500);
  }
});

// Health check
app.get('/health', (req, res) => {
  res.json({ status: 'ok', uptime: process.uptime() });
});

// Analytics endpoint
app.get('/analytics', async (req, res) => {
  const { SupportTicket } = require('./models/SupportTicket');
  
  try {
    const totalTickets = await SupportTicket.count();
    const botHandled = await SupportTicket.count({ where: { resolvedBy: 'bot' } });
    const escalated = await SupportTicket.count({ where: { status: 'escalated' } });
    
    const botResolutionRate = ((botHandled / totalTickets) * 100).toFixed(1);
    
    res.json({
      totalTickets,
      botHandled,
      escalated,
      botResolutionRate: `${botResolutionRate}%`,
      avgResolutionTime: '45 seconds' // Calculate from actual data
    });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// Start server
const PORT = process.env.PORT || 3000;

(async () => {
  // Sync database
  await sequelize.sync();
  console.log('✅ Database synced');

  // Start server
  app.listen(PORT, () => {
    console.log(`🚀 Support bot server running on port ${PORT}`);
    console.log(`📡 Webhook: http://localhost:${PORT}/webhook/whatsapp`);
    
    // Set up webhook (run once)
    // supportBot.whatsapp.setupWebhook('https://your-domain.com/webhook/whatsapp');
  });
})();

// Add to IntentClassifier
const locales = {
  en: { greeting: 'Hello! How can I help?', ... },
  es: { greeting: '¡Hola! ¿Cómo puedo ayudarte?', ... },
  fr: { greeting: 'Bonjour! Comment puis-je vous aider?', ... }
};

function detectLanguage(message) {
  // Use language detection library (e.g., franc, langdetect)
  const franc = require('franc');
  return franc(message); // Returns 'eng', 'spa', 'fra', etc.
}

// Detect frustrated customers and escalate immediately
const Sentiment = require('sentiment');
const sentiment = new Sentiment();

const result = sentiment.analyze(message);

if (result.score < -2) {
  // Customer is frustrated → escalate
  await this.escalateToHuman(ticket, phoneNumber, message);
}

// Send proactive messages based on user behavior
async function sendProactiveSupport() {
  // Example: Order delayed
  const delayedOrders = await getDelayedOrders();
  
  for (const order of delayedOrders) {
    await whatsapp.sendMessage(
      order.customerPhone,
      `Hi ${order.customerName}! We noticed your order #${order.number} is delayed by 1 day. We've expedited shipping and it will arrive tomorrow. Sorry for the inconvenience! 🙏`
    );
  }
}

// Full bidirectional sync
class ZendeskIntegration {
  async createTicket(supportTicket) {
    // Create ticket in Zendesk when escalated
  }
  
  async updateTicket(ticketId, status) {
    // Update Zendesk ticket when resolved
  }
  
  async syncAgentReplies() {
    // Poll Zendesk for agent replies and send to WhatsApp
  }
}

// Similar pattern for Intercom, Freshdesk, Help Scout, etc.

// Calculate support bot KPIs
async function calculateMetrics() {
  const totalTickets = await SupportTicket.count();
  const botResolved = await SupportTicket.count({ where: { resolvedBy: 'bot' } });
  const escalated = await SupportTicket.count({ where: { status: 'escalated' } });
  
  const avgResolutionTime = await SupportTicket.findAll({
    attributes: [[sequelize.fn('AVG', sequelize.col('resolutionTime')), 'avgTime']]
  });
  
  return {
    botEfficiency: ((botResolved / totalTickets) * 100).toFixed(1) + '%',
    escalationRate: ((escalated / totalTickets) * 100).toFixed(1) + '%',
    avgResolutionTime: avgResolutionTime[0].dataValues.avgTime + ' seconds',
    costSavings: calculateCostSavings(botResolved)
  };
}

function calculateCostSavings(botResolvedCount) {
  const avgHumanCost = 7; // $7 per ticket
  const botCost = 0.003; // $0.003 per message
  
  return ((avgHumanCost - botCost) * botResolvedCount).toFixed(2);
}