// Adobe XD Cloud Document API integration
class AdobeXDService {
    constructor(clientId, clientSecret) {
        this.clientId = clientId;
        this.clientSecret = clientSecret;
        this.accessToken = null;
        this.baseURL = 'https://xd.adobe.io/v2';
    }
    
    async authenticate() {
        try {
            const response = await fetch('https://ims-na1.adobelogin.com/ims/token/v3', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/x-www-form-urlencoded'
                },
                body: new URLSearchParams({
                    'grant_type': 'client_credentials',
                    'client_id': this.clientId,
                    'client_secret': this.clientSecret,
                    'scope': 'openid,creative_cloud'
                })
            });
            
            const data = await response.json();
            this.accessToken = data.access_token;
            return this.accessToken;
        } catch (error) {
            console.error('XD authentication failed:', error);
            throw new Error('Adobe XD API authentication failed');
        }
    }
    
    async getCloudDocuments() {
        try {
            if (!this.accessToken) await this.authenticate();
            
            const response = await fetch(`${this.baseURL}/documents`, {
                headers: {
                    'Authorization': `Bearer ${this.accessToken}`,
                    'x-api-key': this.clientId
                }
            });
            
            const data = await response.json();
            return data.documents.map(doc => ({
                id: doc.id,
                name: doc.name,
                created: doc.created,
                modified: doc.modified,
                version: doc.version,
                thumbnail: doc.thumbnail,
                shareUrl: doc.shareUrl
            }));
        } catch (error) {
            console.error('Failed to get cloud documents:', error);
            throw new Error('Unable to retrieve XD documents');
        }
    }
    
    async getArtboards(documentId) {
        try {
            const response = await fetch(`${this.baseURL}/documents/${documentId}/artboards`, {
                headers: {
                    'Authorization': `Bearer ${this.accessToken}`,
                    'x-api-key': this.clientId
                }
            });
            
            const data = await response.json();
            return data.artboards.map(artboard => ({
                id: artboard.id,
                name: artboard.name,
                width: artboard.bounds.width,
                height: artboard.bounds.height,
                x: artboard.bounds.x,
                y: artboard.bounds.y
            }));
        } catch (error) {
            console.error('Failed to get artboards:', error);
            throw new Error('Unable to retrieve artboards');
        }
    }
    
    async exportArtboard(documentId, artboardId, format = 'png', scale = 2) {
        try {
            const response = await fetch(
                `${this.baseURL}/documents/${documentId}/artboards/${artboardId}/renditions`,
                {
                    method: 'POST',
                    headers: {
                        'Authorization': `Bearer ${this.accessToken}`,
                        'x-api-key': this.clientId,
                        'Content-Type': 'application/json'
                    },
                    body: JSON.stringify({
                        format: format,
                        scale: scale,
                        quality: format === 'jpg' ? 90 : undefined
                    })
                }
            );
            
            const data = await response.json();
            return data.renditions[0].downloadUrl;
        } catch (error) {
            console.error('Artboard export failed:', error);
            throw new Error('Unable to export artboard');
        }
    }
    
    async getPrototypeInteractions(documentId) {
        try {
            const response = await fetch(
                `${this.baseURL}/documents/${documentId}/interactions`,
                {
                    headers: {
                        'Authorization': `Bearer ${this.accessToken}`,
                        'x-api-key': this.clientId
                    }
                }
            );
            
            const data = await response.json();
            return data.interactions.map(interaction => ({
                source: interaction.source,
                target: interaction.target,
                trigger: interaction.trigger,
                action: interaction.action,
                transition: interaction.transition
            }));
        } catch (error) {
            console.error('Failed to get interactions:', error);
            throw new Error('Unable to retrieve prototype interactions');
        }
    }
    
    async generateDesignSpecs(documentId, artboardId) {
        try {
            const response = await fetch(
                `${this.baseURL}/documents/${documentId}/artboards/${artboardId}/specs`,
                {
                    headers: {
                        'Authorization': `Bearer ${this.accessToken}`,
                        'x-api-key': this.clientId
                    }
                }
            );
            
            const data = await response.json();
            return {
                css: data.css,
                assets: data.assets,
                measurements: data.measurements,
                colors: data.colors,
                fonts: data.fonts
            };
        } catch (error) {
            console.error('Design specs generation failed:', error);
            throw new Error('Unable to generate design specs');
        }
    }
    
    async shareDocument(documentId, permissions = 'view') {
        try {
            const response = await fetch(
                `${this.baseURL}/documents/${documentId}/share`,
                {
                    method: 'POST',
                    headers: {
                        'Authorization': `Bearer ${this.accessToken}`,
                        'x-api-key': this.clientId,
                        'Content-Type': 'application/json'
                    },
                    body: JSON.stringify({
                        permissions: permissions,
                        allowComments: true,
                        passwordProtected: false
                    })
                }
            );
            
            const data = await response.json();
            return {
                shareUrl: data.shareUrl,
                embeddUrl: data.embeddUrl,
                expiresAt: data.expiresAt
            };
        } catch (error) {
            console.error('Document sharing failed:', error);
            throw new Error('Unable to share document');
        }
    }
}

// Usage example
const xdService = new AdobeXDService(
    process.env.ADOBE_CLIENT_ID,
    process.env.ADOBE_CLIENT_SECRET
);

async function processXDDesigns() {
    try {
        // Get all cloud documents
        const documents = await xdService.getCloudDocuments();
        console.log('Found documents:', documents.length);
        
        for (const doc of documents) {
            // Get artboards for each document
            const artboards = await xdService.getArtboards(doc.id);
            console.log(`Document ${doc.name} has ${artboards.length} artboards`);
            
            // Export each artboard as PNG
            for (const artboard of artboards) {
                const downloadUrl = await xdService.exportArtboard(
                    doc.id,
                    artboard.id,
                    'png',
                    2
                );
                console.log(`Artboard ${artboard.name} exported: ${downloadUrl}`);
            }
            
            // Get prototype interactions
            const interactions = await xdService.getPrototypeInteractions(doc.id);
            console.log(`Found ${interactions.length} interactions`);
            
            // Share document publicly
            const shareInfo = await xdService.shareDocument(doc.id, 'view');
            console.log(`Document shared: ${shareInfo.shareUrl}`);
        }
    } catch (error) {
        console.error('XD processing failed:', error);
    }
}