// Calendly API Integration
class CalendlyAPI {
    constructor(accessToken) {
        this.token = accessToken;
        this.baseURL = 'https://api.calendly.com';
    }
    
    async getUserInfo() {
        const response = await fetch(`${this.baseURL}/users/me`, {
            headers: {
                'Authorization': `Bearer ${this.token}`,
                'Content-Type': 'application/json'
            }
        });
        
        return response.json();
    }
    
    async getEventTypes(userUri) {
        const response = await fetch(`${this.baseURL}/event_types?user=${userUri}`, {
            headers: {
                'Authorization': `Bearer ${this.token}`,
                'Content-Type': 'application/json'
            }
        });
        
        return response.json();
    }
    
    async getScheduledEvents(userUri, startTime, endTime) {
        const params = new URLSearchParams({
            user: userUri,
            min_start_time: startTime,
            max_start_time: endTime
        });
        
        const response = await fetch(`${this.baseURL}/scheduled_events?${params}`, {
            headers: {
                'Authorization': `Bearer ${this.token}`,
                'Content-Type': 'application/json'
            }
        });
        
        return response.json();
    }
    
    async createWebhook(url, events, scope) {
        const response = await fetch(`${this.baseURL}/webhook_subscriptions`, {
            method: 'POST',
            headers: {
                'Authorization': `Bearer ${this.token}`,
                'Content-Type': 'application/json'
            },
            body: JSON.stringify({
                url: url,
                events: events,
                organization: scope.organization,
                user: scope.user
            })
        });
        
        return response.json();
    }
}

// Calendly Webhooks Handler
class CalendlyWebhooks {
    constructor(webhookSigningKey) {
        this.signingKey = webhookSigningKey;
    }
    
    verifyWebhook(payload, timestamp, signature) {
        const crypto = require('crypto');
        const data = timestamp + '.' + payload;
        const expectedSignature = crypto
            .createHmac('sha256', this.signingKey)
            .update(data, 'utf8')
            .digest('base64');
        
        return signature === expectedSignature;
    }
    
    async handleWebhookEvent(event) {
        switch (event.event) {
            case 'invitee.created':
                await this.handleInviteeCreated(event.payload);
                break;
                
            case 'invitee.canceled':
                await this.handleInviteeCanceled(event.payload);
                break;
                
            case 'invitee.rescheduled':
                await this.handleInviteeRescheduled(event.payload);
                break;
                
            default:
                console.log(`Unhandled event: ${event.event}`);
        }
    }
    
    async handleInviteeCreated(payload) {
        console.log('New booking created:', payload.uri);
        
        const eventDetails = {
            name: payload.name,
            email: payload.email,
            eventName: payload.event.name,
            startTime: payload.start_time,
            endTime: payload.end_time,
            location: payload.event.location
        };
        
        // Send to CRM
        await this.syncToCRM(eventDetails);
        
        // Send confirmation email
        await this.sendConfirmationEmail(eventDetails);
        
        // Notify team via Slack
        await this.notifyTeam(eventDetails);
        
        // Create calendar reminder
        await this.createReminders(eventDetails);
    }
    
    async syncToCRM(eventDetails) {
        // HubSpot integration
        const hubspotContact = {
            properties: {
                email: eventDetails.email,
                firstname: eventDetails.name.split(' ')[0],
                lastname: eventDetails.name.split(' ').slice(1).join(' '),
                meeting_scheduled: true,
                meeting_date: eventDetails.startTime,
                meeting_type: eventDetails.eventName
            }
        };
        
        // Create or update contact in HubSpot
        return fetch('https://api.hubapi.com/crm/v3/objects/contacts', {
            method: 'POST',
            headers: {
                'Authorization': `Bearer ${process.env.HUBSPOT_TOKEN}`,
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(hubspotContact)
        });
    }
    
    async sendConfirmationEmail(eventDetails) {
        const emailTemplate = {
            to: eventDetails.email,
            subject: `Confirmed: ${eventDetails.eventName}`,
            html: `
                <h2>Meeting Confirmed!</h2>
                <p>Hi ${eventDetails.name},</p>
                <p>Your meeting has been confirmed for:</p>
                <ul>
                    <li><strong>Date:</strong> ${new Date(eventDetails.startTime).toLocaleDateString()}</li>
                    <li><strong>Time:</strong> ${new Date(eventDetails.startTime).toLocaleTimeString()}</li>
                    <li><strong>Duration:</strong> ${this.calculateDuration(eventDetails.startTime, eventDetails.endTime)} minutes</li>
                    <li><strong>Location:</strong> ${eventDetails.location.join_url || eventDetails.location.location}</li>
                </ul>
                <p>Looking forward to speaking with you!</p>
            `
        };
        
        // Send via email service (SendGrid, AWS SES, etc.)
        return this.emailService.send(emailTemplate);
    }
}

// Calendly Widget Embedding
class CalendlyWidget {
    constructor(username) {
        this.username = username;
        this.baseURL = `https://calendly.com/${username}`;
    }
    
    // Inline embed
    embedInline(containerId, eventType = '') {
        const widget = document.createElement('div');
        widget.className = 'calendly-inline-widget';
        widget.style.minWidth = '320px';
        widget.style.height = '630px';
        widget.setAttribute('data-url', `${this.baseURL}${eventType}`);
        
        document.getElementById(containerId).appendChild(widget);
        
        // Load Calendly script
        this.loadCalendlyScript();
    }
    
    // Popup widget
    createPopupTrigger(buttonId, eventType = '', prefill = {}) {
        const button = document.getElementById(buttonId);
        
        button.addEventListener('click', () => {
            Calendly.initPopupWidget({
                url: `${this.baseURL}${eventType}`,
                prefill: prefill,
                utm: {
                    utmCampaign: 'website',
                    utmSource: 'button',
                    utmMedium: 'popup'
                }
            });
        });
        
        this.loadCalendlyScript();
    }
    
    // Badge widget
    createBadge(eventType = '') {
        const badge = document.createElement('link');
        badge.href = `${this.baseURL}${eventType}`;
        badge.setAttribute('data-url', `${this.baseURL}${eventType}`);
        badge.className = 'calendly-badge-widget';
        badge.innerHTML = 'Schedule time with me';
        
        document.body.appendChild(badge);
        this.loadCalendlyScript();
    }
    
    loadCalendlyScript() {
        if (!document.querySelector('script[src*="calendly.com"]')) {
            const script = document.createElement('script');
            script.src = 'https://assets.calendly.com/assets/external/widget.js';
            script.async = true;
            document.head.appendChild(script);
        }
    }
    
    // Custom prefill data
    setupPrefill(userData) {
        return {
            name: userData.name,
            firstName: userData.firstName,
            lastName: userData.lastName,
            email: userData.email,
            customAnswers: {
                a1: userData.company,
                a2: userData.role,
                a3: userData.interests
            }
        };
    }
}

// Usage example
const calendlyWidget = new CalendlyWidget('your-username');

// Embed inline widget
calendlyWidget.embedInline('calendly-container', '/30min');

// Create popup trigger
calendlyWidget.createPopupTrigger('schedule-button', '/demo', {
    name: 'John Doe',
    email: 'john@example.com'
});