// InVision API integration for workflow automation
class InVisionService {
    constructor(apiToken, teamId) {
        this.apiToken = apiToken;
        this.teamId = teamId;
        this.baseURL = 'https://api.invisionapp.com/v1';
        this.headers = {
            'Authorization': `Bearer ${apiToken}`,
            'Content-Type': 'application/json'
        };
    }
    
    async getProjects() {
        try {
            const response = await fetch(`${this.baseURL}/teams/${this.teamId}/projects`, {
                headers: this.headers
            });
            
            const data = await response.json();
            return data.projects.map(project => ({
                id: project.id,
                name: project.name,
                type: project.type,
                status: project.status,
                created: project.createdAt,
                updated: project.updatedAt,
                url: project.publicUrl
            }));
        } catch (error) {
            console.error('Failed to get projects:', error);
            throw new Error('Unable to retrieve projects');
        }
    }
    
    async createProject(projectData) {
        try {
            const response = await fetch(`${this.baseURL}/teams/${this.teamId}/projects`, {
                method: 'POST',
                headers: this.headers,
                body: JSON.stringify({
                    name: projectData.name,
                    type: projectData.type || 'prototype',
                    description: projectData.description
                })
            });
            
            const project = await response.json();
            return project;
        } catch (error) {
            console.error('Project creation failed:', error);
            throw new Error('Unable to create project');
        }
    }
    
    async uploadScreens(projectId, screens) {
        const uploadedScreens = [];
        
        for (const screen of screens) {
            try {
                // First, get upload URL
                const uploadResponse = await fetch(
                    `${this.baseURL}/projects/${projectId}/screens/upload`,
                    {
                        method: 'POST',
                        headers: this.headers,
                        body: JSON.stringify({
                            filename: screen.filename,
                            contentType: screen.contentType
                        })
                    }
                );
                
                const uploadData = await uploadResponse.json();
                
                // Upload file
                const fileResponse = await fetch(uploadData.uploadUrl, {
                    method: 'PUT',
                    body: screen.file,
                    headers: {
                        'Content-Type': screen.contentType
                    }
                });
                
                if (fileResponse.ok) {
                    // Create screen record
                    const screenResponse = await fetch(
                        `${this.baseURL}/projects/${projectId}/screens`,
                        {
                            method: 'POST',
                            headers: this.headers,
                            body: JSON.stringify({
                                name: screen.name,
                                imageUrl: uploadData.imageUrl,
                                order: screen.order || 0
                            })
                        }
                    );
                    
                    const screenData = await screenResponse.json();
                    uploadedScreens.push(screenData);
                }
            } catch (error) {
                console.error(`Failed to upload screen ${screen.name}:`, error);
            }
        }
        
        return uploadedScreens;
    }
    
    async createHotspots(projectId, screenId, hotspots) {
        const createdHotspots = [];
        
        for (const hotspot of hotspots) {
            try {
                const response = await fetch(
                    `${this.baseURL}/projects/${projectId}/screens/${screenId}/hotspots`,
                    {
                        method: 'POST',
                        headers: this.headers,
                        body: JSON.stringify({
                            x: hotspot.x,
                            y: hotspot.y,
                            width: hotspot.width,
                            height: hotspot.height,
                            targetScreenId: hotspot.targetScreenId,
                            transitionType: hotspot.transition || 'slideLeft',
                            gesture: hotspot.gesture || 'tap'
                        })
                    }
                );
                
                const hotspotData = await response.json();
                createdHotspots.push(hotspotData);
            } catch (error) {
                console.error('Hotspot creation failed:', error);
            }
        }
        
        return createdHotspots;
    }
    
    async getComments(projectId, screenId) {
        try {
            const response = await fetch(
                `${this.baseURL}/projects/${projectId}/screens/${screenId}/comments`,
                { headers: this.headers }
            );
            
            const data = await response.json();
            return data.comments.map(comment => ({
                id: comment.id,
                text: comment.text,
                author: comment.author,
                created: comment.createdAt,
                x: comment.x,
                y: comment.y,
                status: comment.status,
                replies: comment.replies || []
            }));
        } catch (error) {
            console.error('Failed to get comments:', error);
            throw new Error('Unable to retrieve comments');
        }
    }
    
    async addComment(projectId, screenId, commentData) {
        try {
            const response = await fetch(
                `${this.baseURL}/projects/${projectId}/screens/${screenId}/comments`,
                {
                    method: 'POST',
                    headers: this.headers,
                    body: JSON.stringify({
                        text: commentData.text,
                        x: commentData.x,
                        y: commentData.y
                    })
                }
            );
            
            const comment = await response.json();
            return comment;
        } catch (error) {
            console.error('Comment creation failed:', error);
            throw new Error('Unable to add comment');
        }
    }
    
    async generateShareableLink(projectId, permissions = {}) {
        try {
            const response = await fetch(
                `${this.baseURL}/projects/${projectId}/share`,
                {
                    method: 'POST',
                    headers: this.headers,
                    body: JSON.stringify({
                        permissions: {
                            canComment: permissions.canComment || true,
                            canInspect: permissions.canInspect || false,
                            requirePassword: permissions.requirePassword || false,
                            password: permissions.password
                        }
                    })
                }
            );
            
            const shareData = await response.json();
            return {
                shareUrl: shareData.publicUrl,
                embedCode: shareData.embedCode,
                expiresAt: shareData.expiresAt
            };
        } catch (error) {
            console.error('Share link generation failed:', error);
            throw new Error('Unable to generate share link');
        }
    }
    
    async createUserTest(projectId, testData) {
        try {
            const response = await fetch(
                `${this.baseURL}/projects/${projectId}/user-tests`,
                {
                    method: 'POST',
                    headers: this.headers,
                    body: JSON.stringify({
                        title: testData.title,
                        description: testData.description,
                        tasks: testData.tasks,
                        demographic: testData.demographic,
                        deviceType: testData.deviceType || 'desktop'
                    })
                }
            );
            
            const userTest = await response.json();
            return userTest;
        } catch (error) {
            console.error('User test creation failed:', error);
            throw new Error('Unable to create user test');
        }
    }
    
    async exportAssets(projectId, screenId, format = 'png', scale = 1) {
        try {
            const response = await fetch(
                `${this.baseURL}/projects/${projectId}/screens/${screenId}/export`,
                {
                    method: 'POST',
                    headers: this.headers,
                    body: JSON.stringify({
                        format: format,
                        scale: scale,
                        includeSpecs: true
                    })
                }
            );
            
            const exportData = await response.json();
            return exportData;
        } catch (error) {
            console.error('Asset export failed:', error);
            throw new Error('Unable to export assets');
        }
    }
    
    async automateDesignHandoff(projectId) {
        try {
            const projects = await this.getProjects();
            const project = projects.find(p => p.id === projectId);
            
            if (!project) {
                throw new Error('Project not found');
            }
            
            // Generate developer specifications
            const specs = await this.generateDeveloperSpecs(projectId);
            
            // Export assets
            const assets = await this.exportProjectAssets(projectId);
            
            // Create handoff package
            const handoffPackage = {
                project: project,
                specifications: specs,
                assets: assets,
                shareUrl: (await this.generateShareableLink(projectId, {
                    canInspect: true,
                    canComment: true
                })).shareUrl,
                generatedAt: new Date().toISOString()
            };
            
            return handoffPackage;
        } catch (error) {
            console.error('Design handoff automation failed:', error);
            throw new Error('Unable to automate design handoff');
        }
    }
}

// Usage example
const invisionService = new InVisionService(
    process.env.INVISION_API_TOKEN,
    process.env.INVISION_TEAM_ID
);

async function manageInVisionWorkflow() {
    try {
        // Create new prototype project
        const project = await invisionService.createProject({
            name: 'Mobile App Redesign',
            type: 'prototype',
            description: 'iOS app redesign with new navigation'
        });
        
        console.log('Project created:', project.id);
        
        // Upload screens
        const screens = [
            {
                name: 'Home Screen',
                filename: 'home.png',
                contentType: 'image/png',
                file: homeScreenFile,
                order: 1
            },
            {
                name: 'Profile Screen', 
                filename: 'profile.png',
                contentType: 'image/png',
                file: profileScreenFile,
                order: 2
            }
        ];
        
        const uploadedScreens = await invisionService.uploadScreens(project.id, screens);
        console.log('Screens uploaded:', uploadedScreens.length);
        
        // Create navigation hotspots
        if (uploadedScreens.length >= 2) {
            await invisionService.createHotspots(project.id, uploadedScreens[0].id, [
                {
                    x: 50, y: 100, width: 80, height: 44,
                    targetScreenId: uploadedScreens[1].id,
                    transition: 'slideLeft',
                    gesture: 'tap'
                }
            ]);
        }
        
        // Generate shareable link for stakeholder review
        const shareInfo = await invisionService.generateShareableLink(project.id, {
            canComment: true,
            canInspect: false
        });
        
        console.log('Prototype ready for review:', shareInfo.shareUrl);
        
        // Setup automated handoff when design is approved
        const handoffPackage = await invisionService.automateDesignHandoff(project.id);
        console.log('Design handoff package ready:', handoffPackage);
        
    } catch (error) {
        console.error('InVision workflow failed:', error);
    }
}