Freshdesk Integration

// Freshdesk API Client Configuration
const axios = require('axios');
const Freshdesk = require('freshdesk-api');

const freshdesk = new Freshdesk(
  process.env.FRESHDESK_DOMAIN,
  process.env.FRESHDESK_API_KEY
);

// Create Ticket from VAI Conversation
async function createFreshdeskTicket(conversationData) {
  const ticketData = {
    description: `**AI Agent Conversation Summary**

**Issue Details:**
- Type: ${conversationData.issueType}
- Priority: ${conversationData.priority}
- Category: ${conversationData.category}

**Conversation Summary:**
${conversationData.fullSummary}

**Customer Information:**
- Email: ${conversationData.userEmail}
- Name: ${conversationData.userName}
- Account ID: ${conversationData.accountId}

**AI Analysis:**
- Sentiment: ${conversationData.sentiment}
- Urgency: ${conversationData.urgency}
- Recommended Action: ${conversationData.recommendedAction}

**Next Steps:**
${conversationData.resolutionPlan}
`,
    subject: conversationData.issueType === 'technical' 
      ? `[AI] Technical Issue: ${conversationData.summary}`
      : `[AI] Customer Inquiry: ${conversationData.summary}`,
    email: conversationData.userEmail,
    priority: conversationData.priority === 'urgent' ? 4 : 2, // 4=Urgent, 2=Medium
    status: 2, // Open
    group_id: determineGroupId(conversationData.issueType),
    custom_fields: {
      vai_conversation_id: conversationData.conversationId,
      vai_agent_type: conversationData.agentType,
      vai_sentiment_score: conversationData.sentimentScore,
      vai_automation_level: conversationData.automationLevel,
      issue_complexity: conversationData.complexity
    }
  };

  try {
    const ticket = await freshdesk.tickets.create(ticketData);
    console.log('Freshdesk ticket created:', ticket.id);
    
    // Add internal note for context
    await freshdesk.notes.create(ticket.id, {
      body: `This ticket was automatically created by VAI AI Agent.
      
Agent Performance:
- Resolution Time: ${conversationData.resolutionTime}s
- Customer Satisfaction: ${conversationData.satisfactionScore}
- Escalation Required: ${conversationData.escalationRequired}

AI Recommendations:
${conversationData.aiRecommendations}
`,
      private: true
    });
    
    return ticket;
  } catch (error) {
    console.error('Error creating Freshdesk ticket:', error);
    throw error;
  }
}

function determineGroupId(issueType) {
  const groupMapping = {
    technical: 20000123456, // Technical Support Group
    billing: 20000123457, // Billing Group
    account: 20000123458, // Account Management Group
    general: 20000123459  // General Support Group
  };
  
  return groupMapping[issueType] || groupMapping.general;
}

// Freshdesk Workflow Automation Logic
class FreshdeskWorkflowAutomation {
  constructor() {
    this.workflows = {
      autoResponse: this.autoResponseWorkflow.bind(this),
      escalation: this.escalationWorkflow.bind(this),
      satisfaction: this.satisfactionWorkflow.bind(this),
      knowledgeSync: this.knowledgeSyncWorkflow.bind(this)
    };
  }

  async processConversation(conversationData) {
    const results = [];
    
    // Determine which workflows to trigger
    if (this.shouldAutoRespond(conversationData)) {
      const result = await this.workflows.autoResponse(conversationData);
      results.push(result);
    }
    
    if (this.shouldEscalate(conversationData)) {
      const result = await this.workflows.escalation(conversationData);
      results.push(result);
    }
    
    if (this.shouldRequestSatisfaction(conversationData)) {
      const result = await this.workflows.satisfaction(conversationData);
      results.push(result);
    }
    
    if (this.shouldSyncToKnowledgeBase(conversationData)) {
      const result = await this.workflows.knowledgeSync(conversationData);
      results.push(result);
    }
    
    return results;
  }

  shouldAutoRespond(conversationData) {
    const commonIssues = [
      'password reset', 'account locked', 'billing inquiry',
      'feature question', 'how to', 'where is'
    ];
    
    return commonIssues.some(issue => 
      conversationData.message.toLowerCase().includes(issue)
    ) && conversationData.confidence > 0.8;
  }

  shouldEscalate(conversationData) {
    return (
      conversationData.sentiment === 'very_negative' ||
      conversationData.urgency === 'high' ||
      conversationData.issueType === 'technical' ||
      conversationData.customerTier === 'enterprise'
    );
  }

  shouldRequestSatisfaction(conversationData) {
    return (
      conversationData.resolved === true &&
      conversationData.interactionCount > 1 &&
      !conversationData.satisfactionRequested
    );
  }

  shouldSyncToKnowledgeBase(conversationData) {
    return (
      conversationData.resolved === true &&
      conversationData.solutionQuality > 0.9 &&
      !conversationData.existsInKnowledgeBase
    );
  }

  async autoResponseWorkflow(conversationData) {
    // Find matching template
    const template = await this.findResponseTemplate(conversationData);
    
    if (template) {
      // Send automated response
      await freshdesk.conversations.reply(conversationData.ticketId, {
        body: template.content,
        user_id: process.env.AI_AGENT_USER_ID
      });
      
      return {
        action: 'auto_response',
        template: template.name,
        confidence: template.confidence
      };
    }
    
    return null;
  }

  async escalationWorkflow(conversationData) {
    // Update ticket priority and group
    const updateData = {
      priority: 4, // High priority
      group_id: this.getEscalationGroup(conversationData.issueType),
      custom_fields: {
        escalation_reason: conversationData.escalationReason,
        escalation_timestamp: new Date().toISOString()
      }
    };
    
    await freshdesk.tickets.update(conversationData.ticketId, updateData);
    
    // Notify escalation team
    await this.notifyEscalationTeam(conversationData);
    
    return {
      action: 'escalation',
      new_priority: 'high',
      assigned_group: updateData.group_id
    };
  }

  async satisfactionWorkflow(conversationData) {
    // Send satisfaction survey
    const surveyLink = this.generateSatisfactionLink(conversationData.ticketId);
    
    await freshdesk.conversations.reply(conversationData.ticketId, {
      body: `How satisfied are you with the support you received?

Please rate your experience: ${surveyLink}

Your feedback helps us improve our service!
`,
      user_id: process.env.AI_AGENT_USER_ID
    });
    
    // Mark satisfaction as requested
    await freshdesk.tickets.update(conversationData.ticketId, {
      custom_fields: {
        satisfaction_requested: true,
        satisfaction_timestamp: new Date().toISOString()
      }
    });
    
    return {
      action: 'satisfaction_survey',
      survey_link: surveyLink
    };
  }

  async knowledgeSyncWorkflow(conversationData) {
    // Extract solution from conversation
    const solution = this.extractSolution(conversationData);
    
    if (solution.quality > 0.9) {
      // Create knowledge base article
      const article = {
        title: solution.title,
        description: solution.description,
        category_id: this.getKnowledgeCategory(conversationData.issueType),
        tags: ['ai-generated', conversationData.issueType, 'automated'],
        status: 2 // Published
      };
      
      const kbArticle = await freshdesk.solutions.create(article);
      
      // Link article to ticket
      await freshdesk.tickets.update(conversationData.ticketId, {
        custom_fields: {
          kb_article_id: kbArticle.id,
          solution_synced: true
        }
      });
      
      return {
        action: 'knowledge_sync',
        article_id: kbArticle.id,
        article_title: kbArticle.title
      };
    }
    
    return null;
  }
}