// Canva Connect API integration
class CanvaService {
    constructor(clientId, clientSecret, redirectUri) {
        this.clientId = clientId;
        this.clientSecret = clientSecret;
        this.redirectUri = redirectUri;
        this.baseURL = 'https://api.canva.com/rest/v1';
        this.accessToken = null;
    }
    
    getAuthorizationUrl() {
        const params = new URLSearchParams({
            client_id: this.clientId,
            response_type: 'code',
            redirect_uri: this.redirectUri,
            scope: 'design:read design:write asset:read asset:write'
        });
        
        return `https://www.canva.com/api/oauth/authorize?${params}`;
    }
    
    async exchangeCodeForToken(authCode) {
        try {
            const response = await fetch('https://api.canva.com/rest/v1/oauth/token', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/x-www-form-urlencoded'
                },
                body: new URLSearchParams({
                    grant_type: 'authorization_code',
                    client_id: this.clientId,
                    client_secret: this.clientSecret,
                    code: authCode,
                    redirect_uri: this.redirectUri
                })
            });
            
            const data = await response.json();
            this.accessToken = data.access_token;
            return data;
        } catch (error) {
            console.error('Token exchange failed:', error);
            throw new Error('Failed to obtain access token');
        }
    }
    
    async createDesignFromTemplate(templateId, customizations) {
        try {
            const response = await fetch(`${this.baseURL}/designs`, {
                method: 'POST',
                headers: {
                    'Authorization': `Bearer ${this.accessToken}`,
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({
                    design_type: customizations.designType || 'presentation',
                    template_id: templateId,
                    title: customizations.title,
                    customizations: customizations.elements || []
                })
            });
            
            const design = await response.json();
            return design;
        } catch (error) {
            console.error('Design creation failed:', error);
            throw new Error('Unable to create design from template');
        }
    }
    
    async getUserDesigns(limit = 50, continuation = null) {
        try {
            const params = new URLSearchParams({
                limit: limit.toString()
            });
            
            if (continuation) {
                params.append('continuation', continuation);
            }
            
            const response = await fetch(`${this.baseURL}/designs?${params}`, {
                headers: {
                    'Authorization': `Bearer ${this.accessToken}`
                }
            });
            
            const data = await response.json();
            return {
                designs: data.items.map(design => ({
                    id: design.id,
                    title: design.title,
                    type: design.design_type,
                    thumbnail: design.thumbnail,
                    created: design.created_at,
                    modified: design.updated_at
                })),
                continuation: data.continuation
            };
        } catch (error) {
            console.error('Failed to get user designs:', error);
            throw new Error('Unable to retrieve user designs');
        }
    }
    
    async exportDesign(designId, format = 'png', quality = 'standard') {
        try {
            const response = await fetch(`${this.baseURL}/designs/${designId}/export`, {
                method: 'POST',
                headers: {
                    'Authorization': `Bearer ${this.accessToken}`,
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({
                    format: format,
                    quality: quality,
                    pages: 'all'
                })
            });
            
            const exportJob = await response.json();
            
            // Poll for export completion
            return await this.pollExportStatus(exportJob.job.id);
        } catch (error) {
            console.error('Design export failed:', error);
            throw new Error('Unable to export design');
        }
    }
    
    async pollExportStatus(jobId, maxAttempts = 30) {
        for (let attempt = 0; attempt < maxAttempts; attempt++) {
            try {
                const response = await fetch(`${this.baseURL}/export/${jobId}`, {
                    headers: {
                        'Authorization': `Bearer ${this.accessToken}`
                    }
                });
                
                const job = await response.json();
                
                if (job.job.status === 'success') {
                    return job.job.urls;
                } else if (job.job.status === 'failed') {
                    throw new Error('Export job failed');
                }
                
                // Wait 2 seconds before next poll
                await new Promise(resolve => setTimeout(resolve, 2000));
            } catch (error) {
                if (attempt === maxAttempts - 1) {
                    throw new Error('Export polling timeout');
                }
            }
        }
    }
    
    async uploadAsset(assetData) {
        try {
            // First, get upload URL
            const uploadResponse = await fetch(`${this.baseURL}/assets/upload`, {
                method: 'POST',
                headers: {
                    'Authorization': `Bearer ${this.accessToken}`,
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({
                    asset_type: assetData.type,
                    name: assetData.name
                })
            });
            
            const uploadData = await uploadResponse.json();
            
            // Upload file to provided URL
            const fileResponse = await fetch(uploadData.upload_url, {
                method: 'PUT',
                body: assetData.file
            });
            
            if (!fileResponse.ok) {
                throw new Error('File upload failed');
            }
            
            return uploadData.asset;
        } catch (error) {
            console.error('Asset upload failed:', error);
            throw new Error('Unable to upload asset');
        }
    }
    
    async createBrandTemplate(brandId, templateData) {
        try {
            const response = await fetch(`${this.baseURL}/brands/${brandId}/templates`, {
                method: 'POST',
                headers: {
                    'Authorization': `Bearer ${this.accessToken}`,
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({
                    name: templateData.name,
                    description: templateData.description,
                    design_id: templateData.designId,
                    locked_elements: templateData.lockedElements || []
                })
            });
            
            const template = await response.json();
            return template;
        } catch (error) {
            console.error('Brand template creation failed:', error);
            throw new Error('Unable to create brand template');
        }
    }
    
    async generateSocialMediaSeries(brandId, campaignData) {
        const designs = [];
        const formats = ['instagram-post', 'instagram-story', 'facebook-post', 'linkedin-post'];
        
        for (const format of formats) {
            try {
                const design = await this.createDesignFromTemplate(
                    campaignData.baseTemplateId,
                    {
                        designType: format,
                        title: `${campaignData.title} - ${format}`,
                        elements: [
                            {
                                type: 'text',
                                content: campaignData.headline,
                                style: campaignData.headlineStyle
                            },
                            {
                                type: 'text',
                                content: campaignData.description,
                                style: campaignData.bodyStyle
                            },
                            {
                                type: 'image',
                                asset_id: campaignData.imageAssetId,
                                position: campaignData.imagePosition
                            }
                        ]
                    }
                );
                
                designs.push({
                    format: format,
                    design: design,
                    editUrl: `https://www.canva.com/design/${design.id}`
                });
            } catch (error) {
                console.error(`Failed to create ${format} design:`, error);
            }
        }
        
        return designs;
    }
}

// Usage example
const canvaService = new CanvaService(
    process.env.CANVA_CLIENT_ID,
    process.env.CANVA_CLIENT_SECRET,
    process.env.CANVA_REDIRECT_URI
);

async function automateMarketingDesigns() {
    try {
        // Setup OAuth flow
        const authUrl = canvaService.getAuthorizationUrl();
        console.log('Authorize at:', authUrl);
        
        // After user authorization, exchange code for token
        // const tokenData = await canvaService.exchangeCodeForToken(authCode);
        
        // Create social media campaign
        const campaign = await canvaService.generateSocialMediaSeries('brand-id', {
            title: 'Summer Sale Campaign',
            baseTemplateId: 'template-123',
            headline: '50% OFF Summer Sale',
            description: 'Limited time offer on all products',
            imageAssetId: 'asset-456',
            headlineStyle: {
                font_family: 'Arial',
                font_size: 48,
                color: '#FF6B6B'
            },
            bodyStyle: {
                font_family: 'Arial',
                font_size: 24,
                color: '#333333'
            }
        });
        
        console.log('Campaign designs created:', campaign.length);
        
        // Export all designs
        for (const item of campaign) {
            const exportUrls = await canvaService.exportDesign(item.design.id, 'png');
            console.log(`${item.format} exported:`, exportUrls[0]);
        }
        
    } catch (error) {
        console.error('Marketing automation failed:', error);
    }
}