// Example: IT Service Request Guidance
// Topic: "I need help with software"
// Flow: Guide user through request types

// In your topic flow:
- Present 3-4 main categories at a time
- Use quick replies for common scenarios
- Progressively narrow down to specific services
- Confirm understanding before proceeding

// Sample conversation flow:
Bot: "I can help you with software requests. What type of help do you need?"
Options: ["New software", "Software issue", "Access request"]

User: "New software"
Bot: "What type of software are you looking for?"
Options: ["Microsoft Office", "Adobe Creative", "Development tools", "Other"]

// Topic Script Example: Context-aware incident creation
(function() {
    // Get current user context
    var currentUser = gs.getUser();
    var userDept = currentUser.getDepartment();
    var recentIncidents = new GlideRecord('incident');
    
    recentIncidents.addQuery('caller_id', currentUser.getID());
    recentIncidents.addQuery('sys_created_on', '>', gs.daysAgoStart(30));
    recentIncidents.orderByDesc('sys_created_on');
    recentIncidents.setLimit(3);
    recentIncidents.query();
    
    // Pre-populate common fields based on context
    var contextData = {
        caller_id: currentUser.getID(),
        location: currentUser.getLocation(),
        department: userDept.toString(),
        company: currentUser.getCompany()
    };
    
    // Suggest categories based on user's role and recent activity
    return contextData;
})();

// Example: Password Reset with Progressive Complexity
// Start simple, add complexity only when needed

Initial Flow:
1. "Is this about your ServiceNow password?" (Yes/No)
2. If Yes: "Can you access your email?" (Yes/No)
3. If Yes: Trigger self-service reset
4. If No: Progressive troubleshooting

Advanced Flow (if self-service fails):
1. "Have you tried these steps?" (Show common solutions)
2. "What error message do you see?" (Entity extraction)
3. "Let me connect you with IT support" (Live agent handoff)

// Example: Expense Approval Request
// Validate before creating records

function validateExpenseRequest(amount, category, receiptAttached) {
    var validation = {
        isValid: true,
        errors: [],
        warnings: []
    };
    
    // Validate amount
    if (amount > 5000 && category !== 'Travel') {
        validation.warnings.push('Large expenses may require additional approval');
    }
    
    // Validate receipt requirement
    if (amount > 25 && !receiptAttached) {
        validation.isValid = false;
        validation.errors.push('Receipt required for expenses over $25');
    }
    
    // Validate category against user's role
    var userRole = gs.getUser().getRoles();
    if (category === 'Equipment' && !userRole.includes('itil')) {
        validation.isValid = false;
        validation.errors.push('Equipment requests require IT approval');
    }
    
    return validation;
}

// Best Practices for Training Data:

// Good Examples (varied, natural language):
"I need to reset my password"
"Can you help me reset my password?"
"My password isn't working"
"I forgot my password"
"Password reset please"
"I can't log in because of my password"

// Bad Examples (repetitive, unnatural):
"reset password"
"reset my password"
"reset the password"
"password reset"
// Too similar - adds noise, not value

// Example: Optimized Entity Configuration for Software Requests

// Entity: software_type
// System Entities: @sys.software-application
// Custom Patterns:
- "Microsoft Office" → office_suite
- "Adobe Creative Suite" → creative_software
- "Visual Studio" → development_tools

// Entity: urgency_level
// Patterns with context:
- "urgent" + "deadline" → high
- "when you can" → low
- "today" OR "ASAP" → high
- "not urgent" → low

// In Topic Flow:
if (entities.software_type && entities.urgency_level) {
    // Skip follow-up questions, proceed directly
    createSoftwareRequest(entities);
} else {
    // Ask clarifying questions for missing entities
}

// Context Management Pattern
function setConversationContext(key, value, ttl = 3600) {
    // Store in Virtual Agent session
    var context = nlapi.getContext();
    context.setValue(key, value);
    context.setTTL(key, ttl); // Expire context after 1 hour
}

function getConversationContext(key) {
    var context = nlapi.getContext();
    return context.getValue(key);
}

// Example: Incident creation across multiple topics
// Topic 1: User mentions "my laptop is slow"
setConversationContext('incident_category', 'hardware');
setConversationContext('affected_ci', 'laptop');

// Topic 2: User provides additional details
var category = getConversationContext('incident_category');
var ci = getConversationContext('affected_ci');
// Continue incident creation with previous context

// Virtual Agent Topic → Flow Designer Pattern

// In Topic: Collect required inputs
var flowInputs = {
    requestor: userContext.caller_id,
    request_type: entities.request_type,
    priority: entities.priority,
    description: userInput.description
};

// Trigger Flow Designer flow
var flowResult = sn_fd.FlowAPI.startFlow('hardware_request_flow', flowInputs);

// Handle flow response in conversation
if (flowResult.success) {
    response.addText("Your request #" + flowResult.request_number + " has been submitted!");
    response.addText("Expected completion: " + flowResult.estimated_completion);
} else {
    response.addText("I encountered an issue creating your request. Let me connect you with support.");
    // Trigger live agent handoff
}

// Example: ServiceNow Virtual Agent + External ITSM Tool

function checkExternalTicketStatus(ticketNumber) {
    var restMessage = new sn_ws.RESTMessageV2();
    restMessage.setEndpoint('https://external-itsm.company.com/api/tickets/' + ticketNumber);
    restMessage.setHttpMethod('GET');
    restMessage.setRequestHeader('Authorization', 'Bearer ' + getExternalAPIKey());
    
    var response = restMessage.execute();
    
    if (response.getStatusCode() == 200) {
        var ticketData = JSON.parse(response.getBody());
        return {
            status: ticketData.status,
            assignee: ticketData.assignee,
            lastUpdate: ticketData.last_modified
        };
    }
    
    return null;
}

// In Virtual Agent Topic:
var externalTicket = checkExternalTicketStatus(userInput.ticket_number);
if (externalTicket) {
    response.addText(`Your ticket is currently ${externalTicket.status}`);
    response.addText(`Assigned to: ${externalTicket.assignee}`);
    response.addText(`Last updated: ${externalTicket.lastUpdate}`);
} else {
    response.addText("I couldn't find that ticket number. Can you double-check?");
}

// Channel-Aware Response Formatting

function formatResponse(message, channel) {
    switch(channel) {
        case 'web':
            return {
                text: message,
                showTyping: true,
                quickReplies: getWebQuickReplies()
            };
            
        case 'mobile':
            return {
                text: message,
                compactMode: true,
                tapActions: getMobileTapActions()
            };
            
        case 'teams':
            return {
                text: message,
                adaptiveCard: getTeamsCard(),
                mentions: getTeamsMentions()
            };
            
        case 'slack':
            return {
                text: message,
                blocks: getSlackBlocks(),
                ephemeral: false
            };
            
        default:
            return { text: message };
    }
}

// Optimized Flow Pattern: Batch Information Collection

// Instead of:
// Bot: "What's your name?"
// User: "John Smith"
// Bot: "What's your department?"
// User: "IT"
// Bot: "What's your issue?"
// User: "Laptop problem"

// Use:
// Bot: "I can help you create a support ticket. Please provide:
//      - Brief description of your issue
//      - How urgent is this? (High/Medium/Low)"
//
// Advanced: Use quick replies with entity extraction
// Bot: "What type of issue are you experiencing?"
// Options with entities:
// - "Hardware problem" → {category: hardware, priority: medium}
// - "Software not working" → {category: software, priority: medium}
// - "Can't access system" → {category: access, priority: high}

// NLU Performance Monitoring Script

function analyzeNLUPerformance() {
    var nluMetrics = new GlideRecord('va_nlu_confidence_log');
    nluMetrics.addQuery('sys_created_on', '>', gs.daysAgoStart(7));
    nluMetrics.orderBy('confidence_score');
    nluMetrics.query();
    
    var lowConfidenceCount = 0;
    var totalInteractions = 0;
    var confidenceSum = 0;
    
    while (nluMetrics.next()) {
        totalInteractions++;
        var confidence = parseFloat(nluMetrics.confidence_score);
        confidenceSum += confidence;
        
        if (confidence < 0.7) {
            lowConfidenceCount++;
            // Log for retraining
            gs.log('Low confidence interaction: ' + nluMetrics.user_input + 
                   ' (Confidence: ' + confidence + ')');
        }
    }
    
    var averageConfidence = confidenceSum / totalInteractions;
    var lowConfidenceRate = (lowConfidenceCount / totalInteractions) * 100;
    
    return {
        averageConfidence: averageConfidence,
        lowConfidenceRate: lowConfidenceRate,
        totalInteractions: totalInteractions
    };
}

// Automated Testing Framework for Virtual Agent

function testVirtualAgentTopic(topicName, testCases) {
    var results = [];
    
    testCases.forEach(function(testCase) {
        var testResult = {
            input: testCase.userInput,
            expectedIntent: testCase.expectedIntent,
            expectedEntities: testCase.expectedEntities,
            passed: false,
            actualResult: null
        };
        
        // Simulate user input
        var nluResult = simulateNLUProcessing(testCase.userInput);
        
        // Validate intent detection
        if (nluResult.intent === testCase.expectedIntent) {
            testResult.passed = true;
        }
        
        // Validate entity extraction
        if (JSON.stringify(nluResult.entities) === JSON.stringify(testCase.expectedEntities)) {
            testResult.passed = testResult.passed && true;
        } else {
            testResult.passed = false;
        }
        
        testResult.actualResult = nluResult;
        results.push(testResult);
    });
    
    return results;
}

// Virtual Agent Analytics Dashboard

function generateVAAnalytics(dateRange) {
    var analytics = {
        totalConversations: 0,
        successfulResolutions: 0,
        liveAgentHandoffs: 0,
        averageConversationLength: 0,
        topIntents: [],
        userSatisfactionScore: 0
    };
    
    // Query conversation logs
    var conversations = new GlideRecord('va_conversation');
    conversations.addQuery('sys_created_on', '>=', dateRange.start);
    conversations.addQuery('sys_created_on', '<=', dateRange.end);
    conversations.query();
    
    var conversationLengths = [];
    var intentCounts = {};
    
    while (conversations.next()) {
        analytics.totalConversations++;
        
        // Track conversation resolution
        if (conversations.resolution_type == 'self_service') {
            analytics.successfulResolutions++;
        } else if (conversations.resolution_type == 'live_agent') {
            analytics.liveAgentHandoffs++;
        }
        
        // Track conversation length
        conversationLengths.push(parseInt(conversations.message_count));
        
        // Track popular intents
        var intent = conversations.primary_intent.toString();
        intentCounts[intent] = (intentCounts[intent] || 0) + 1;
    }
    
    // Calculate averages
    analytics.averageConversationLength = conversationLengths.reduce((a, b) => a + b, 0) / conversationLengths.length;
    analytics.resolutionRate = (analytics.successfulResolutions / analytics.totalConversations) * 100;
    
    // Sort top intents
    analytics.topIntents = Object.entries(intentCounts)
        .sort(([,a], [,b]) => b - a)
        .slice(0, 10);
    
    return analytics;
}