// Freshdesk API Integration
class FreshdeskAPI {
    constructor(domain, apiKey) {
        this.domain = domain;
        this.apiKey = apiKey;
        this.baseURL = `https://${domain}.freshdesk.com/api/v2`;
        this.headers = {
            'Authorization': `Basic ${Buffer.from(apiKey + ':X').toString('base64')}`,
            'Content-Type': 'application/json'
        };
    }
    
    async createTicket(ticketData) {
        const response = await fetch(`${this.baseURL}/tickets`, {
            method: 'POST',
            headers: this.headers,
            body: JSON.stringify(ticketData)
        });
        
        return response.json();
    }
    
    async updateTicket(ticketId, updateData) {
        const response = await fetch(`${this.baseURL}/tickets/${ticketId}`, {
            method: 'PUT',
            headers: this.headers,
            body: JSON.stringify(updateData)
        });
        
        return response.json();
    }
    
    async getTickets(filters = {}) {
        const params = new URLSearchParams(filters);
        const response = await fetch(`${this.baseURL}/tickets?${params}`, {
            headers: this.headers
        });
        
        return response.json();
    }
    
    async createContact(contactData) {
        const response = await fetch(`${this.baseURL}/contacts`, {
            method: 'POST',
            headers: this.headers,
            body: JSON.stringify(contactData)
        });
        
        return response.json();
    }
    
    async addNoteToTicket(ticketId, note) {
        const response = await fetch(`${this.baseURL}/tickets/${ticketId}/notes`, {
            method: 'POST',
            headers: this.headers,
            body: JSON.stringify({
                body: note,
                private: false
            })
        });
        
        return response.json();
    }
}

// Freshdesk Widget Configuration
class FreshdeskWidget {
    constructor(domain) {
        this.domain = domain;
        this.widgetId = 'fd-widget';
    }
    
    init(config = {}) {
        window.fwSettings = {
            'widget_id': 64000000005,
            'locale': config.locale || 'en',
            'defaultDepartment': config.department || 'Support'
        };
        
        const script = document.createElement('script');
        script.type = 'text/javascript';
        script.src = `https://widget.freshworks.com/widgets/${this.widgetId}.js`;
        script.async = true;
        script.defer = true;
        
        document.head.appendChild(script);
    }
    
    openWidget() {
        if (window.FreshworksWidget) {
            window.FreshworksWidget('open');
        }
    }
    
    closeWidget() {
        if (window.FreshworksWidget) {
            window.FreshworksWidget('hide');
        }
    }
    
    identify(userData) {
        if (window.FreshworksWidget) {
            window.FreshworksWidget('identify', 'ticketForm', {
                name: userData.name,
                email: userData.email,
                phone: userData.phone,
                externalId: userData.userId
            });
        }
    }
    
    setCustomProperties(properties) {
        if (window.FreshworksWidget) {
            window.FreshworksWidget('setProperties', properties);
        }
    }
}

// Freshdesk Automation Rules
class FreshdeskAutomation {
    constructor(api) {
        this.api = api;
    }
    
    async createTicketFromEmail(emailData) {
        const ticketData = {
            name: emailData.fromName,
            email: emailData.fromEmail,
            subject: emailData.subject,
            description: emailData.body,
            status: 2, // Open
            priority: this.determinePriority(emailData.subject),
            source: 1, // Email
            tags: this.extractTags(emailData.subject, emailData.body)
        };
        
        return this.api.createTicket(ticketData);
    }
    
    determinePriority(subject) {
        const urgentKeywords = ['urgent', 'critical', 'emergency', 'down', 'broken'];
        const subjectLower = subject.toLowerCase();
        
        if (urgentKeywords.some(keyword => subjectLower.includes(keyword))) {
            return 4; // Urgent
        }
        
        return 1; // Low
    }
    
    extractTags(subject, body) {
        const tags = [];
        const content = (subject + ' ' + body).toLowerCase();
        
        const tagMappings = {
            'billing': ['billing', 'payment', 'invoice', 'subscription'],
            'technical': ['error', 'bug', 'crash', 'not working'],
            'feature': ['feature', 'enhancement', 'suggestion'],
            'account': ['account', 'login', 'password', 'access']
        };
        
        Object.entries(tagMappings).forEach(([tag, keywords]) => {
            if (keywords.some(keyword => content.includes(keyword))) {
                tags.push(tag);
            }
        });
        
        return tags;
    }
    
    async autoAssignTicket(ticketId, subject, customerTier) {
        let assigneeId;
        
        // Route based on subject and customer tier
        if (subject.toLowerCase().includes('billing')) {
            assigneeId = '64000000001'; // Billing specialist
        } else if (customerTier === 'enterprise') {
            assigneeId = '64000000002'; // Senior support
        } else {
            assigneeId = '64000000003'; // General support
        }
        
        return this.api.updateTicket(ticketId, {
            responder_id: assigneeId
        });
    }
    
    async escalateTicket(ticketId, reason) {
        await this.api.updateTicket(ticketId, {
            priority: 4, // Urgent
            status: 2    // Open
        });
        
        await this.api.addNoteToTicket(ticketId, 
            `Ticket escalated: ${reason}. Requires immediate attention.`
        );
        
        // Notify manager
        await this.notifyManager(ticketId, reason);
    }
    
    async createSLAReminder(ticketId, slaDeadline) {
        const warningTime = new Date(slaDeadline.getTime() - 60 * 60 * 1000); // 1 hour before
        
        setTimeout(async () => {
            await this.api.addNoteToTicket(ticketId, 
                'SLA Warning: This ticket is approaching its SLA deadline.'
            );
        }, warningTime.getTime() - Date.now());
    }
}

// Freshdesk Webhooks Handler
class FreshdeskWebhooks {
    constructor() {
        this.webhookSecret = process.env.FRESHDESK_WEBHOOK_SECRET;
    }
    
    async handleWebhook(event, payload) {
        switch (event) {
            case 'ticket_create':
                await this.handleTicketCreated(payload);
                break;
                
            case 'ticket_update':
                await this.handleTicketUpdated(payload);
                break;
                
            case 'ticket_resolve':
                await this.handleTicketResolved(payload);
                break;
                
            case 'note_create':
                await this.handleNoteCreated(payload);
                break;
                
            default:
                console.log(`Unhandled webhook event: ${event}`);
        }
    }
    
    async handleTicketCreated(ticket) {
        console.log(`New ticket created: ${ticket.subject}`);
        
        // Send Slack notification
        await this.notifySlack({
            channel: '#support',
            text: `🎫 New ticket: ${ticket.subject}`,
            fields: [
                { title: 'From', value: ticket.requester_name, short: true },
                { title: 'Priority', value: ticket.priority_name, short: true },
                { title: 'Status', value: ticket.status_name, short: true }
            ]
        });
        
        // Log in analytics
        await this.trackAnalytics('ticket_created', {
            priority: ticket.priority,
            source: ticket.source_name,
            department: ticket.group_name
        });
    }
    
    async handleTicketResolved(ticket) {
        console.log(`Ticket resolved: ${ticket.subject}`);
        
        // Send satisfaction survey
        await this.sendSatisfactionSurvey(ticket);
        
        // Update customer record
        await this.updateCustomerRecord(ticket.requester_id, {
            last_support_interaction: new Date(),
            tickets_resolved: '+1'
        });
    }
}